[PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C

qemu-devel.nongnu.org archive mirror
 help / color / mirror / Atom feed

* [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C
@ 2022-09-05  9:55 Milica Lazarevic
  2022-09-05  9:55 ` [PATCH v2 01/20] disas/nanomips: Remove namespace img Milica Lazarevic
                   ` (19 more replies)
  0 siblings, 20 replies; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic

Hi,

This patchset converts the nanomips disassembler to plain C. C++ features
like class, std::string type, exception handling, and function overloading
have been removed and replaced with the equivalent C code. 

===============================
Changes since previous version:
    (1) disas/nanomips: Remove namespace img
      Removed comments that refer to the deleted function.
    (3) disas/nanomips: Delete NMD class fields
      Class fields were introduced as global variables in the previous version.
      Since it wasn't a thread-safe solution, in this version, one class field
      (m_requested_instruction_categories) has been replaced with the only value 
      it can have, while the other class field has been added as a parameter 
      where needed.
    (4) disas/nanomips: Remove helper methods from class
      Squashed patch #19 here.
    (5) disas/nanomips: Remove __cond methods from class
      Addressed the coding style issues.
    (6) disas/nanomips: Remove disasm methods from class
      Addressed the coding style issues.
    (12) disas/nanomips: Replace std::string type
      Changed the return types to char * when a function returns allocated memory.
      Switched to using some glib functions for memory allocation like g_malloc,
      g_strdup_vprintf, and g_strdup_printf instead of strdup.
    (13) disas/nanomips: Prevent memory leaking
      Used the g_autofree attribute for dynamically allocated strings, instead of
      calling free(). Now, this patch is much smaller than in the previous version.
    (14) disas/nanomips: Introduce Dis_info struct
      Same as in (3). Instead of using global variables, all the necessary information
      are packed into the struct and added as an argument wherever needed.

Regards, 
Milica

Milica Lazarevic (20):
      disas/nanomips: Remove namespace img
      disas/nanomips: Extract enums out of the NMD class
      disas/nanomips: Delete NMD class fields
      disas/nanomips: Remove helper methods from class
      disas/nanomips: Remove __cond methods from class
      disas/nanomips: Remove disasm methods from class
      disas/nanomips: Remove Pool tables from the class
      disas/nanomips: Remove NMD class
      disas/nanomips: Move typedefs etc to nanomips.cpp
      disas/nanomips: Delete nanomips.h
      disas/nanomips: Remove #inlcude <sstream>
      disas/nanomips: Replace std::string type
      disas/nanomips: Prevent memory leaking
      disas/nanomips: Remove function overloading
      disas/nanomips: Introduce Dis_info struct
      disas/nanomips: Replace exception handling
      disas/nanomips: Replace Cpp enums for C enums
      disas/nanomips: Remove argument passing by ref
      disas/nanomips: Add struct keyword
      disas/nanomips: Rename nanomips.cpp to nanomips.c

 disas/meson.build                  |    2 +-
 disas/{nanomips.cpp => nanomips.c} | 7155 ++++++++++++++++++------------------
 disas/nanomips.h                   | 1072 ------
 3 files changed, 3557 insertions(+), 4672 deletions(-)




^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 01/20] disas/nanomips: Remove namespace img
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:00   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 02/20] disas/nanomips: Extract enums out of the NMD class Milica Lazarevic
                   ` (18 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

Since there's no namespace feature in C, namespace img has been replaced
with adding the prefix "img" to the namespace members.

Prefix "img" has been added to the function names of functions that used
to be wrapped in namespace img. Those are img::format() functions.
I.e. replaced img::format with the img_format.

Typedef address that used to belong to namespace img now is called
img_address.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
---
 disas/nanomips.cpp | 1433 ++++++++++++++++++++++----------------------
 disas/nanomips.h   |   10 +-
 2 files changed, 712 insertions(+), 731 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index 9be8df75dd..84529685bf 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -137,131 +137,118 @@ int print_insn_nanomips(bfd_vma memaddr, struct disassemble_info *info)
 }
 
 
-namespace img
+std::string img_format(const char *format, ...)
 {
-    address addr32(address a)
-    {
-        return a;
+    char buffer[256];
+    va_list args;
+    va_start(args, format);
+    int err = vsprintf(buffer, format, args);
+    if (err < 0) {
+        perror(buffer);
     }
+    va_end(args);
+    return buffer;
+}
 
-    std::string format(const char *format, ...)
-    {
-        char buffer[256];
-        va_list args;
-        va_start(args, format);
-        int err = vsprintf(buffer, format, args);
-        if (err < 0) {
-            perror(buffer);
-        }
-        va_end(args);
-        return buffer;
-    }
-
-    std::string format(const char *format,
-                       std::string s)
-    {
-        char buffer[256];
-
-        sprintf(buffer, format, s.c_str());
+std::string img_format(const char *format,
+                   std::string s)
+{
+    char buffer[256];
 
-        return buffer;
-    }
+    sprintf(buffer, format, s.c_str());
 
-    std::string format(const char *format,
-                       std::string s1,
-                       std::string s2)
-    {
-        char buffer[256];
+    return buffer;
+}
 
-        sprintf(buffer, format, s1.c_str(), s2.c_str());
+std::string img_format(const char *format,
+                   std::string s1,
+                   std::string s2)
+{
+    char buffer[256];
 
-        return buffer;
-    }
+    sprintf(buffer, format, s1.c_str(), s2.c_str());
 
-    std::string format(const char *format,
-                       std::string s1,
-                       std::string s2,
-                       std::string s3)
-    {
-        char buffer[256];
+    return buffer;
+}
 
-        sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str());
+std::string img_format(const char *format,
+                   std::string s1,
+                   std::string s2,
+                   std::string s3)
+{
+    char buffer[256];
 
-        return buffer;
-    }
+    sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str());
 
-    std::string format(const char *format,
-                       std::string s1,
-                       std::string s2,
-                       std::string s3,
-                       std::string s4)
-    {
-        char buffer[256];
+    return buffer;
+}
 
-        sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str(),
-                                s4.c_str());
+std::string img_format(const char *format,
+                   std::string s1,
+                   std::string s2,
+                   std::string s3,
+                   std::string s4)
+{
+    char buffer[256];
 
-        return buffer;
-    }
+    sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str(),
+                            s4.c_str());
 
-    std::string format(const char *format,
-                       std::string s1,
-                       std::string s2,
-                       std::string s3,
-                       std::string s4,
-                       std::string s5)
-    {
-        char buffer[256];
+    return buffer;
+}
 
-        sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str(),
-                                s4.c_str(), s5.c_str());
+std::string img_format(const char *format,
+                   std::string s1,
+                   std::string s2,
+                   std::string s3,
+                   std::string s4,
+                   std::string s5)
+{
+    char buffer[256];
 
-        return buffer;
-    }
+    sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str(),
+                            s4.c_str(), s5.c_str());
 
-    std::string format(const char *format,
-                       uint64 d,
-                       std::string s2)
-    {
-        char buffer[256];
+    return buffer;
+}
 
-        sprintf(buffer, format, d, s2.c_str());
+std::string img_format(const char *format,
+                   uint64 d,
+                   std::string s2)
+{
+    char buffer[256];
 
-        return buffer;
-    }
+    sprintf(buffer, format, d, s2.c_str());
 
-    std::string format(const char *format,
-                       std::string s1,
-                       uint64 d,
-                       std::string s2)
-    {
-        char buffer[256];
+    return buffer;
+}
 
-        sprintf(buffer, format, s1.c_str(), d, s2.c_str());
+std::string img_format(const char *format,
+                   std::string s1,
+                   uint64 d,
+                   std::string s2)
+{
+    char buffer[256];
 
-        return buffer;
-    }
+    sprintf(buffer, format, s1.c_str(), d, s2.c_str());
 
-    std::string format(const char *format,
-                       std::string s1,
-                       std::string s2,
-                       uint64 d)
-    {
-        char buffer[256];
+    return buffer;
+}
 
-        sprintf(buffer, format, s1.c_str(), s2.c_str(), d);
+std::string img_format(const char *format,
+                   std::string s1,
+                   std::string s2,
+                   uint64 d)
+{
+    char buffer[256];
 
-        return buffer;
-    }
+    sprintf(buffer, format, s1.c_str(), s2.c_str(), d);
 
-    char as_char(int c)
-    {
-        return static_cast<char>(c);
-    }
-};
+    return buffer;
+}
 
 
-std::string to_string(img::address a)
+std::string to_string(img_address a)
 {
     char buffer[256];
     sprintf(buffer, "0x%" PRIx64, a);
@@ -289,7 +276,7 @@ uint64 NMD::renumber_registers(uint64 index, uint64 *register_list,
         return register_list[index];
     }
 
-    throw std::runtime_error(img::format(
+    throw std::runtime_error(img_format(
                    "Invalid register mapping index %" PRIu64
                    ", size of list = %zu",
                    index, register_list_size));
@@ -683,7 +670,7 @@ std::string NMD::save_restore_list(uint64 rt, uint64 count, uint64 gp)
     for (uint64 counter = 0; counter != count; counter++) {
         bool use_gp = gp && (counter == count - 1);
         uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
-        str += img::format(",%s", GPR(this_rt));
+        str += img_format(",%s", GPR(this_rt));
     }
 
     return str;
@@ -703,7 +690,7 @@ std::string NMD::GPR(uint64 reg)
         return gpr_reg[reg];
     }
 
-    throw std::runtime_error(img::format("Invalid GPR register index %" PRIu64,
+    throw std::runtime_error(img_format("Invalid GPR register index %" PRIu64,
                                          reg));
 }
 
@@ -721,7 +708,7 @@ std::string NMD::FPR(uint64 reg)
         return fpr_reg[reg];
     }
 
-    throw std::runtime_error(img::format("Invalid FPR register index %" PRIu64,
+    throw std::runtime_error(img_format("Invalid FPR register index %" PRIu64,
                                          reg));
 }
 
@@ -736,37 +723,35 @@ std::string NMD::AC(uint64 reg)
         return ac_reg[reg];
     }
 
-    throw std::runtime_error(img::format("Invalid AC register index %" PRIu64,
+    throw std::runtime_error(img_format("Invalid AC register index %" PRIu64,
                                          reg));
 }
 
 
 std::string NMD::IMMEDIATE(uint64 value)
 {
-    return img::format("0x%" PRIx64, value);
+    return img_format("0x%" PRIx64, value);
 }
 
 
 std::string NMD::IMMEDIATE(int64 value)
 {
-    return img::format("%" PRId64, value);
+    return img_format("%" PRId64, value);
 }
 
 
 std::string NMD::CPR(uint64 reg)
 {
     /* needs more work */
-    return img::format("CP%" PRIu64, reg);
+    return img_format("CP%" PRIu64, reg);
 }
 
 
 std::string NMD::ADDRESS(uint64 value, int instruction_size)
 {
     /* token for string replace */
-    /* const char TOKEN_REPLACE = (char)0xa2; */
-    img::address address = m_pc + value + instruction_size;
+    img_address address = m_pc + value + instruction_size;
     /* symbol replacement */
-    /* return img::as_char(TOKEN_REPLACE) + to_string(address); */
     return to_string(address);
 }
 
@@ -1807,7 +1792,7 @@ std::string NMD::ABS_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string fd = FPR(copy(fd_value));
 
-    return img::format("ABS.D %s, %s", fd, fs);
+    return img_format("ABS.D %s, %s", fd, fs);
 }
 
 
@@ -1829,7 +1814,7 @@ std::string NMD::ABS_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string fd = FPR(copy(fd_value));
 
-    return img::format("ABS.S %s, %s", fd, fs);
+    return img_format("ABS.S %s, %s", fd, fs);
 }
 
 
@@ -1851,7 +1836,7 @@ std::string NMD::ABSQ_S_PH(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("ABSQ_S.PH %s, %s", rt, rs);
+    return img_format("ABSQ_S.PH %s, %s", rt, rs);
 }
 
 
@@ -1873,7 +1858,7 @@ std::string NMD::ABSQ_S_QB(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("ABSQ_S.QB %s, %s", rt, rs);
+    return img_format("ABSQ_S.QB %s, %s", rt, rs);
 }
 
 
@@ -1895,7 +1880,7 @@ std::string NMD::ABSQ_S_W(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("ABSQ_S.W %s, %s", rt, rs);
+    return img_format("ABSQ_S.W %s, %s", rt, rs);
 }
 
 
@@ -1918,7 +1903,7 @@ std::string NMD::ACLR(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("ACLR %s, %s(%s)", bit, s, rs);
+    return img_format("ACLR %s, %s(%s)", bit, s, rs);
 }
 
 
@@ -1941,7 +1926,7 @@ std::string NMD::ADD(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADD %s, %s, %s", rd, rs, rt);
+    return img_format("ADD %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -1966,7 +1951,7 @@ std::string NMD::ADD_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string fd = FPR(copy(fd_value));
 
-    return img::format("ADD.D %s, %s, %s", fd, fs, ft);
+    return img_format("ADD.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -1991,7 +1976,7 @@ std::string NMD::ADD_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string fd = FPR(copy(fd_value));
 
-    return img::format("ADD.S %s, %s, %s", fd, fs, ft);
+    return img_format("ADD.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -2014,7 +1999,7 @@ std::string NMD::ADDIU_32_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("ADDIU %s, %s, %s", rt, rs, u);
+    return img_format("ADDIU %s, %s, %s", rt, rs, u);
 }
 
 
@@ -2035,7 +2020,7 @@ std::string NMD::ADDIU_48_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = IMMEDIATE(copy(s_value));
 
-    return img::format("ADDIU %s, %s", rt, s);
+    return img_format("ADDIU %s, %s", rt, s);
 }
 
 
@@ -2056,7 +2041,7 @@ std::string NMD::ADDIU_GP48_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = IMMEDIATE(copy(s_value));
 
-    return img::format("ADDIU %s, $%d, %s", rt, 28, s);
+    return img_format("ADDIU %s, $%d, %s", rt, 28, s);
 }
 
 
@@ -2077,7 +2062,7 @@ std::string NMD::ADDIU_GP_B_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("ADDIU %s, $%d, %s", rt, 28, u);
+    return img_format("ADDIU %s, $%d, %s", rt, 28, u);
 }
 
 
@@ -2098,7 +2083,7 @@ std::string NMD::ADDIU_GP_W_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("ADDIU %s, $%d, %s", rt, 28, u);
+    return img_format("ADDIU %s, $%d, %s", rt, 28, u);
 }
 
 
@@ -2121,7 +2106,7 @@ std::string NMD::ADDIU_NEG_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string u = IMMEDIATE(neg_copy(u_value));
 
-    return img::format("ADDIU %s, %s, %s", rt, rs, u);
+    return img_format("ADDIU %s, %s, %s", rt, rs, u);
 }
 
 
@@ -2142,7 +2127,7 @@ std::string NMD::ADDIU_R1_SP_(uint64 instruction)
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("ADDIU %s, $%d, %s", rt3, 29, u);
+    return img_format("ADDIU %s, $%d, %s", rt3, 29, u);
 }
 
 
@@ -2165,7 +2150,7 @@ std::string NMD::ADDIU_R2_(uint64 instruction)
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("ADDIU %s, %s, %s", rt3, rs3, u);
+    return img_format("ADDIU %s, %s, %s", rt3, rs3, u);
 }
 
 
@@ -2185,7 +2170,7 @@ std::string NMD::ADDIU_RS5_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = IMMEDIATE(copy(s_value));
 
-    return img::format("ADDIU %s, %s", rt, s);
+    return img_format("ADDIU %s, %s", rt, s);
 }
 
 
@@ -2207,7 +2192,7 @@ std::string NMD::ADDIUPC_32_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("ADDIUPC %s, %s", rt, s);
+    return img_format("ADDIUPC %s, %s", rt, s);
 }
 
 
@@ -2229,7 +2214,7 @@ std::string NMD::ADDIUPC_48_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 6);
 
-    return img::format("ADDIUPC %s, %s", rt, s);
+    return img_format("ADDIUPC %s, %s", rt, s);
 }
 
 
@@ -2253,7 +2238,7 @@ std::string NMD::ADDQ_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDQ.PH %s, %s, %s", rd, rs, rt);
+    return img_format("ADDQ.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2278,7 +2263,7 @@ std::string NMD::ADDQ_S_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
+    return img_format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2302,7 +2287,7 @@ std::string NMD::ADDQ_S_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
+    return img_format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2327,7 +2312,7 @@ std::string NMD::ADDQH_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDQH.PH %s, %s, %s", rd, rs, rt);
+    return img_format("ADDQH.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2352,7 +2337,7 @@ std::string NMD::ADDQH_R_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
+    return img_format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2377,7 +2362,7 @@ std::string NMD::ADDQH_R_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
+    return img_format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2402,7 +2387,7 @@ std::string NMD::ADDQH_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDQH.W %s, %s, %s", rd, rs, rt);
+    return img_format("ADDQH.W %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2426,7 +2411,7 @@ std::string NMD::ADDSC(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDSC %s, %s, %s", rd, rs, rt);
+    return img_format("ADDSC %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2449,7 +2434,7 @@ std::string NMD::ADDU_16_(uint64 instruction)
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
     std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
 
-    return img::format("ADDU %s, %s, %s", rd3, rs3, rt3);
+    return img_format("ADDU %s, %s, %s", rd3, rs3, rt3);
 }
 
 
@@ -2473,7 +2458,7 @@ std::string NMD::ADDU_32_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDU %s, %s, %s", rd, rs, rt);
+    return img_format("ADDU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2495,7 +2480,7 @@ std::string NMD::ADDU_4X4_(uint64 instruction)
     std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
     std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
 
-    return img::format("ADDU %s, %s", rs4, rt4);
+    return img_format("ADDU %s, %s", rs4, rt4);
 }
 
 
@@ -2519,7 +2504,7 @@ std::string NMD::ADDU_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDU.PH %s, %s, %s", rd, rs, rt);
+    return img_format("ADDU.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2543,7 +2528,7 @@ std::string NMD::ADDU_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDU.QB %s, %s, %s", rd, rs, rt);
+    return img_format("ADDU.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2568,7 +2553,7 @@ std::string NMD::ADDU_S_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
+    return img_format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2592,7 +2577,7 @@ std::string NMD::ADDU_S_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
+    return img_format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2617,7 +2602,7 @@ std::string NMD::ADDUH_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDUH.QB %s, %s, %s", rd, rs, rt);
+    return img_format("ADDUH.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2642,7 +2627,7 @@ std::string NMD::ADDUH_R_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
+    return img_format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
 }
 
 /*
@@ -2665,7 +2650,7 @@ std::string NMD::ADDWC(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ADDWC %s, %s, %s", rd, rs, rt);
+    return img_format("ADDWC %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2687,7 +2672,7 @@ std::string NMD::ALUIPC(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
+    return img_format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
 }
 
 
@@ -2708,7 +2693,7 @@ std::string NMD::AND_16_(uint64 instruction)
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
-    return img::format("AND %s, %s", rs3, rt3);
+    return img_format("AND %s, %s", rs3, rt3);
 }
 
 
@@ -2732,7 +2717,7 @@ std::string NMD::AND_32_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("AND %s, %s, %s", rd, rs, rt);
+    return img_format("AND %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -2755,7 +2740,7 @@ std::string NMD::ANDI_16_(uint64 instruction)
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
     std::string eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
 
-    return img::format("ANDI %s, %s, %s", rt3, rs3, eu);
+    return img_format("ANDI %s, %s, %s", rt3, rs3, eu);
 }
 
 
@@ -2779,7 +2764,7 @@ std::string NMD::ANDI_32_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("ANDI %s, %s, %s", rt, rs, u);
+    return img_format("ANDI %s, %s, %s", rt, rs, u);
 }
 
 
@@ -2803,7 +2788,7 @@ std::string NMD::APPEND(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("APPEND %s, %s, %s", rt, rs, sa);
+    return img_format("APPEND %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -2827,7 +2812,7 @@ std::string NMD::ASET(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("ASET %s, %s(%s)", bit, s, rs);
+    return img_format("ASET %s, %s(%s)", bit, s, rs);
 }
 
 
@@ -2847,7 +2832,7 @@ std::string NMD::BALC_16_(uint64 instruction)
 
     std::string s = ADDRESS(encode_s_from_address(s_value), 2);
 
-    return img::format("BALC %s", s);
+    return img_format("BALC %s", s);
 }
 
 
@@ -2867,7 +2852,7 @@ std::string NMD::BALC_32_(uint64 instruction)
 
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BALC %s", s);
+    return img_format("BALC %s", s);
 }
 
 
@@ -2889,7 +2874,7 @@ std::string NMD::BALRSC(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("BALRSC %s, %s", rt, rs);
+    return img_format("BALRSC %s, %s", rt, rs);
 }
 
 
@@ -2913,7 +2898,7 @@ std::string NMD::BBEQZC(uint64 instruction)
     std::string bit = IMMEDIATE(copy(bit_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BBEQZC %s, %s, %s", rt, bit, s);
+    return img_format("BBEQZC %s, %s, %s", rt, bit, s);
 }
 
 
@@ -2937,7 +2922,7 @@ std::string NMD::BBNEZC(uint64 instruction)
     std::string bit = IMMEDIATE(copy(bit_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BBNEZC %s, %s, %s", rt, bit, s);
+    return img_format("BBNEZC %s, %s, %s", rt, bit, s);
 }
 
 
@@ -2957,7 +2942,7 @@ std::string NMD::BC_16_(uint64 instruction)
 
     std::string s = ADDRESS(encode_s_from_address(s_value), 2);
 
-    return img::format("BC %s", s);
+    return img_format("BC %s", s);
 }
 
 
@@ -2977,7 +2962,7 @@ std::string NMD::BC_32_(uint64 instruction)
 
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BC %s", s);
+    return img_format("BC %s", s);
 }
 
 
@@ -2999,7 +2984,7 @@ std::string NMD::BC1EQZC(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BC1EQZC %s, %s", ft, s);
+    return img_format("BC1EQZC %s, %s", ft, s);
 }
 
 
@@ -3021,7 +3006,7 @@ std::string NMD::BC1NEZC(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BC1NEZC %s, %s", ft, s);
+    return img_format("BC1NEZC %s, %s", ft, s);
 }
 
 
@@ -3043,7 +3028,7 @@ std::string NMD::BC2EQZC(uint64 instruction)
     std::string ct = CPR(copy(ct_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BC2EQZC %s, %s", ct, s);
+    return img_format("BC2EQZC %s, %s", ct, s);
 }
 
 
@@ -3065,7 +3050,7 @@ std::string NMD::BC2NEZC(uint64 instruction)
     std::string ct = CPR(copy(ct_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BC2NEZC %s, %s", ct, s);
+    return img_format("BC2NEZC %s, %s", ct, s);
 }
 
 
@@ -3089,7 +3074,7 @@ std::string NMD::BEQC_16_(uint64 instruction)
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
     std::string u = ADDRESS(encode_u_from_address(u_value), 2);
 
-    return img::format("BEQC %s, %s, %s", rs3, rt3, u);
+    return img_format("BEQC %s, %s, %s", rs3, rt3, u);
 }
 
 
@@ -3113,7 +3098,7 @@ std::string NMD::BEQC_32_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BEQC %s, %s, %s", rs, rt, s);
+    return img_format("BEQC %s, %s, %s", rs, rt, s);
 }
 
 
@@ -3137,7 +3122,7 @@ std::string NMD::BEQIC(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BEQIC %s, %s, %s", rt, u, s);
+    return img_format("BEQIC %s, %s, %s", rt, u, s);
 }
 
 
@@ -3159,7 +3144,7 @@ std::string NMD::BEQZC_16_(uint64 instruction)
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 2);
 
-    return img::format("BEQZC %s, %s", rt3, s);
+    return img_format("BEQZC %s, %s", rt3, s);
 }
 
 
@@ -3183,7 +3168,7 @@ std::string NMD::BGEC(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BGEC %s, %s, %s", rs, rt, s);
+    return img_format("BGEC %s, %s, %s", rs, rt, s);
 }
 
 
@@ -3207,7 +3192,7 @@ std::string NMD::BGEIC(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BGEIC %s, %s, %s", rt, u, s);
+    return img_format("BGEIC %s, %s, %s", rt, u, s);
 }
 
 
@@ -3231,7 +3216,7 @@ std::string NMD::BGEIUC(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BGEIUC %s, %s, %s", rt, u, s);
+    return img_format("BGEIUC %s, %s, %s", rt, u, s);
 }
 
 
@@ -3255,7 +3240,7 @@ std::string NMD::BGEUC(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BGEUC %s, %s, %s", rs, rt, s);
+    return img_format("BGEUC %s, %s, %s", rs, rt, s);
 }
 
 
@@ -3279,7 +3264,7 @@ std::string NMD::BLTC(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BLTC %s, %s, %s", rs, rt, s);
+    return img_format("BLTC %s, %s, %s", rs, rt, s);
 }
 
 
@@ -3303,7 +3288,7 @@ std::string NMD::BLTIC(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BLTIC %s, %s, %s", rt, u, s);
+    return img_format("BLTIC %s, %s, %s", rt, u, s);
 }
 
 
@@ -3327,7 +3312,7 @@ std::string NMD::BLTIUC(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BLTIUC %s, %s, %s", rt, u, s);
+    return img_format("BLTIUC %s, %s, %s", rt, u, s);
 }
 
 
@@ -3351,7 +3336,7 @@ std::string NMD::BLTUC(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BLTUC %s, %s, %s", rs, rt, s);
+    return img_format("BLTUC %s, %s, %s", rs, rt, s);
 }
 
 
@@ -3375,7 +3360,7 @@ std::string NMD::BNEC_16_(uint64 instruction)
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
     std::string u = ADDRESS(encode_u_from_address(u_value), 2);
 
-    return img::format("BNEC %s, %s, %s", rs3, rt3, u);
+    return img_format("BNEC %s, %s, %s", rs3, rt3, u);
 }
 
 
@@ -3399,7 +3384,7 @@ std::string NMD::BNEC_32_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BNEC %s, %s, %s", rs, rt, s);
+    return img_format("BNEC %s, %s, %s", rs, rt, s);
 }
 
 
@@ -3423,7 +3408,7 @@ std::string NMD::BNEIC(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BNEIC %s, %s, %s", rt, u, s);
+    return img_format("BNEIC %s, %s, %s", rt, u, s);
 }
 
 
@@ -3445,7 +3430,7 @@ std::string NMD::BNEZC_16_(uint64 instruction)
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 2);
 
-    return img::format("BNEZC %s, %s", rt3, s);
+    return img_format("BNEZC %s, %s", rt3, s);
 }
 
 
@@ -3465,7 +3450,7 @@ std::string NMD::BPOSGE32C(uint64 instruction)
 
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("BPOSGE32C %s", s);
+    return img_format("BPOSGE32C %s", s);
 }
 
 
@@ -3485,7 +3470,7 @@ std::string NMD::BREAK_16_(uint64 instruction)
 
     std::string code = IMMEDIATE(copy(code_value));
 
-    return img::format("BREAK %s", code);
+    return img_format("BREAK %s", code);
 }
 
 
@@ -3505,7 +3490,7 @@ std::string NMD::BREAK_32_(uint64 instruction)
 
     std::string code = IMMEDIATE(copy(code_value));
 
-    return img::format("BREAK %s", code);
+    return img_format("BREAK %s", code);
 }
 
 
@@ -3525,7 +3510,7 @@ std::string NMD::BRSC(uint64 instruction)
 
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("BRSC %s", rs);
+    return img_format("BRSC %s", rs);
 }
 
 
@@ -3549,7 +3534,7 @@ std::string NMD::CACHE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("CACHE %s, %s(%s)", op, s, rs);
+    return img_format("CACHE %s, %s(%s)", op, s, rs);
 }
 
 
@@ -3573,7 +3558,7 @@ std::string NMD::CACHEE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("CACHEE %s, %s(%s)", op, s, rs);
+    return img_format("CACHEE %s, %s(%s)", op, s, rs);
 }
 
 
@@ -3595,7 +3580,7 @@ std::string NMD::CEIL_L_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CEIL.L.D %s, %s", ft, fs);
+    return img_format("CEIL.L.D %s, %s", ft, fs);
 }
 
 
@@ -3617,7 +3602,7 @@ std::string NMD::CEIL_L_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CEIL.L.S %s, %s", ft, fs);
+    return img_format("CEIL.L.S %s, %s", ft, fs);
 }
 
 
@@ -3639,7 +3624,7 @@ std::string NMD::CEIL_W_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CEIL.W.D %s, %s", ft, fs);
+    return img_format("CEIL.W.D %s, %s", ft, fs);
 }
 
 
@@ -3661,7 +3646,7 @@ std::string NMD::CEIL_W_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CEIL.W.S %s, %s", ft, fs);
+    return img_format("CEIL.W.S %s, %s", ft, fs);
 }
 
 
@@ -3683,7 +3668,7 @@ std::string NMD::CFC1(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string cs = CPR(copy(cs_value));
 
-    return img::format("CFC1 %s, %s", rt, cs);
+    return img_format("CFC1 %s, %s", rt, cs);
 }
 
 
@@ -3705,7 +3690,7 @@ std::string NMD::CFC2(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string cs = CPR(copy(cs_value));
 
-    return img::format("CFC2 %s, %s", rt, cs);
+    return img_format("CFC2 %s, %s", rt, cs);
 }
 
 
@@ -3727,7 +3712,7 @@ std::string NMD::CLASS_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CLASS.D %s, %s", ft, fs);
+    return img_format("CLASS.D %s, %s", ft, fs);
 }
 
 
@@ -3749,7 +3734,7 @@ std::string NMD::CLASS_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CLASS.S %s, %s", ft, fs);
+    return img_format("CLASS.S %s, %s", ft, fs);
 }
 
 
@@ -3771,7 +3756,7 @@ std::string NMD::CLO(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("CLO %s, %s", rt, rs);
+    return img_format("CLO %s, %s", rt, rs);
 }
 
 
@@ -3793,7 +3778,7 @@ std::string NMD::CLZ(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("CLZ %s, %s", rt, rs);
+    return img_format("CLZ %s, %s", rt, rs);
 }
 
 
@@ -3817,7 +3802,7 @@ std::string NMD::CMP_AF_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.AF.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.AF.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -3841,7 +3826,7 @@ std::string NMD::CMP_AF_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.AF.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.AF.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -3865,7 +3850,7 @@ std::string NMD::CMP_EQ_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -3886,7 +3871,7 @@ std::string NMD::CMP_EQ_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMP.EQ.PH %s, %s", rs, rt);
+    return img_format("CMP.EQ.PH %s, %s", rs, rt);
 }
 
 
@@ -3910,7 +3895,7 @@ std::string NMD::CMP_EQ_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -3934,7 +3919,7 @@ std::string NMD::CMP_LE_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.LE.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.LE.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -3955,7 +3940,7 @@ std::string NMD::CMP_LE_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMP.LE.PH %s, %s", rs, rt);
+    return img_format("CMP.LE.PH %s, %s", rs, rt);
 }
 
 
@@ -3979,7 +3964,7 @@ std::string NMD::CMP_LE_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.LE.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.LE.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4003,7 +3988,7 @@ std::string NMD::CMP_LT_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.LT.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.LT.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4024,7 +4009,7 @@ std::string NMD::CMP_LT_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMP.LT.PH %s, %s", rs, rt);
+    return img_format("CMP.LT.PH %s, %s", rs, rt);
 }
 
 
@@ -4048,7 +4033,7 @@ std::string NMD::CMP_LT_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.LT.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.LT.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4072,7 +4057,7 @@ std::string NMD::CMP_NE_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.NE.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.NE.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4096,7 +4081,7 @@ std::string NMD::CMP_NE_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.NE.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.NE.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4120,7 +4105,7 @@ std::string NMD::CMP_OR_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.OR.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.OR.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4144,7 +4129,7 @@ std::string NMD::CMP_OR_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.OR.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.OR.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4168,7 +4153,7 @@ std::string NMD::CMP_SAF_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4192,7 +4177,7 @@ std::string NMD::CMP_SAF_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4216,7 +4201,7 @@ std::string NMD::CMP_SEQ_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4240,7 +4225,7 @@ std::string NMD::CMP_SEQ_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4264,7 +4249,7 @@ std::string NMD::CMP_SLE_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4288,7 +4273,7 @@ std::string NMD::CMP_SLE_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4312,7 +4297,7 @@ std::string NMD::CMP_SLT_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4336,7 +4321,7 @@ std::string NMD::CMP_SLT_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4360,7 +4345,7 @@ std::string NMD::CMP_SNE_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4384,7 +4369,7 @@ std::string NMD::CMP_SNE_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4408,7 +4393,7 @@ std::string NMD::CMP_SOR_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4432,7 +4417,7 @@ std::string NMD::CMP_SOR_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4456,7 +4441,7 @@ std::string NMD::CMP_SUEQ_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4480,7 +4465,7 @@ std::string NMD::CMP_SUEQ_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4504,7 +4489,7 @@ std::string NMD::CMP_SULE_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4528,7 +4513,7 @@ std::string NMD::CMP_SULE_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4552,7 +4537,7 @@ std::string NMD::CMP_SULT_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4576,7 +4561,7 @@ std::string NMD::CMP_SULT_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4600,7 +4585,7 @@ std::string NMD::CMP_SUN_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4624,7 +4609,7 @@ std::string NMD::CMP_SUNE_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4648,7 +4633,7 @@ std::string NMD::CMP_SUNE_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4672,7 +4657,7 @@ std::string NMD::CMP_SUN_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4696,7 +4681,7 @@ std::string NMD::CMP_UEQ_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4720,7 +4705,7 @@ std::string NMD::CMP_UEQ_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4744,7 +4729,7 @@ std::string NMD::CMP_ULE_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4768,7 +4753,7 @@ std::string NMD::CMP_ULE_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4792,7 +4777,7 @@ std::string NMD::CMP_ULT_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4816,7 +4801,7 @@ std::string NMD::CMP_ULT_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4840,7 +4825,7 @@ std::string NMD::CMP_UN_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.UN.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.UN.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4864,7 +4849,7 @@ std::string NMD::CMP_UNE_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4888,7 +4873,7 @@ std::string NMD::CMP_UNE_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4912,7 +4897,7 @@ std::string NMD::CMP_UN_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("CMP.UN.S %s, %s, %s", fd, fs, ft);
+    return img_format("CMP.UN.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -4937,7 +4922,7 @@ std::string NMD::CMPGDU_EQ_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
+    return img_format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -4962,7 +4947,7 @@ std::string NMD::CMPGDU_LE_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
+    return img_format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -4987,7 +4972,7 @@ std::string NMD::CMPGDU_LT_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
+    return img_format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -5012,7 +4997,7 @@ std::string NMD::CMPGU_EQ_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
+    return img_format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -5037,7 +5022,7 @@ std::string NMD::CMPGU_LE_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
+    return img_format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -5062,7 +5047,7 @@ std::string NMD::CMPGU_LT_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
+    return img_format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -5084,7 +5069,7 @@ std::string NMD::CMPU_EQ_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMPU.EQ.QB %s, %s", rs, rt);
+    return img_format("CMPU.EQ.QB %s, %s", rs, rt);
 }
 
 
@@ -5106,7 +5091,7 @@ std::string NMD::CMPU_LE_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMPU.LE.QB %s, %s", rs, rt);
+    return img_format("CMPU.LE.QB %s, %s", rs, rt);
 }
 
 
@@ -5128,7 +5113,7 @@ std::string NMD::CMPU_LT_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("CMPU.LT.QB %s, %s", rs, rt);
+    return img_format("CMPU.LT.QB %s, %s", rs, rt);
 }
 
 
@@ -5148,7 +5133,7 @@ std::string NMD::COP2_1(uint64 instruction)
 
     std::string cofun = IMMEDIATE(copy(cofun_value));
 
-    return img::format("COP2_1 %s", cofun);
+    return img_format("COP2_1 %s", cofun);
 }
 
 
@@ -5170,7 +5155,7 @@ std::string NMD::CTC1(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string cs = CPR(copy(cs_value));
 
-    return img::format("CTC1 %s, %s", rt, cs);
+    return img_format("CTC1 %s, %s", rt, cs);
 }
 
 
@@ -5192,7 +5177,7 @@ std::string NMD::CTC2(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string cs = CPR(copy(cs_value));
 
-    return img::format("CTC2 %s, %s", rt, cs);
+    return img_format("CTC2 %s, %s", rt, cs);
 }
 
 
@@ -5214,7 +5199,7 @@ std::string NMD::CVT_D_L(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.D.L %s, %s", ft, fs);
+    return img_format("CVT.D.L %s, %s", ft, fs);
 }
 
 
@@ -5236,7 +5221,7 @@ std::string NMD::CVT_D_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.D.S %s, %s", ft, fs);
+    return img_format("CVT.D.S %s, %s", ft, fs);
 }
 
 
@@ -5258,7 +5243,7 @@ std::string NMD::CVT_D_W(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.D.W %s, %s", ft, fs);
+    return img_format("CVT.D.W %s, %s", ft, fs);
 }
 
 
@@ -5280,7 +5265,7 @@ std::string NMD::CVT_L_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.L.D %s, %s", ft, fs);
+    return img_format("CVT.L.D %s, %s", ft, fs);
 }
 
 
@@ -5302,7 +5287,7 @@ std::string NMD::CVT_L_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.L.S %s, %s", ft, fs);
+    return img_format("CVT.L.S %s, %s", ft, fs);
 }
 
 
@@ -5324,7 +5309,7 @@ std::string NMD::CVT_S_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.S.D %s, %s", ft, fs);
+    return img_format("CVT.S.D %s, %s", ft, fs);
 }
 
 
@@ -5346,7 +5331,7 @@ std::string NMD::CVT_S_L(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.S.L %s, %s", ft, fs);
+    return img_format("CVT.S.L %s, %s", ft, fs);
 }
 
 
@@ -5368,7 +5353,7 @@ std::string NMD::CVT_S_PL(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.S.PL %s, %s", ft, fs);
+    return img_format("CVT.S.PL %s, %s", ft, fs);
 }
 
 
@@ -5390,7 +5375,7 @@ std::string NMD::CVT_S_PU(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.S.PU %s, %s", ft, fs);
+    return img_format("CVT.S.PU %s, %s", ft, fs);
 }
 
 
@@ -5412,7 +5397,7 @@ std::string NMD::CVT_S_W(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.S.W %s, %s", ft, fs);
+    return img_format("CVT.S.W %s, %s", ft, fs);
 }
 
 
@@ -5434,7 +5419,7 @@ std::string NMD::CVT_W_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.W.D %s, %s", ft, fs);
+    return img_format("CVT.W.D %s, %s", ft, fs);
 }
 
 
@@ -5456,7 +5441,7 @@ std::string NMD::CVT_W_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("CVT.W.S %s, %s", ft, fs);
+    return img_format("CVT.W.S %s, %s", ft, fs);
 }
 
 
@@ -5478,7 +5463,7 @@ std::string NMD::DADDIU_48_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = IMMEDIATE(copy(s_value));
 
-    return img::format("DADDIU %s, %s", rt, s);
+    return img_format("DADDIU %s, %s", rt, s);
 }
 
 
@@ -5502,7 +5487,7 @@ std::string NMD::DADDIU_NEG_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string u = IMMEDIATE(neg_copy(u_value));
 
-    return img::format("DADDIU %s, %s, %s", rt, rs, u);
+    return img_format("DADDIU %s, %s, %s", rt, rs, u);
 }
 
 
@@ -5526,7 +5511,7 @@ std::string NMD::DADDIU_U12_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("DADDIU %s, %s, %s", rt, rs, u);
+    return img_format("DADDIU %s, %s, %s", rt, rs, u);
 }
 
 
@@ -5550,7 +5535,7 @@ std::string NMD::DADD(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DADD %s, %s, %s", rd, rs, rt);
+    return img_format("DADD %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -5574,7 +5559,7 @@ std::string NMD::DADDU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DADDU %s, %s, %s", rd, rs, rt);
+    return img_format("DADDU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -5596,7 +5581,7 @@ std::string NMD::DCLO(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("DCLO %s, %s", rt, rs);
+    return img_format("DCLO %s, %s", rt, rs);
 }
 
 
@@ -5618,7 +5603,7 @@ std::string NMD::DCLZ(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("DCLZ %s, %s", rt, rs);
+    return img_format("DCLZ %s, %s", rt, rs);
 }
 
 
@@ -5642,7 +5627,7 @@ std::string NMD::DDIV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DDIV %s, %s, %s", rd, rs, rt);
+    return img_format("DDIV %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -5666,7 +5651,7 @@ std::string NMD::DDIVU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DDIVU %s, %s, %s", rd, rs, rt);
+    return img_format("DDIVU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -5710,7 +5695,7 @@ std::string NMD::DEXTM(uint64 instruction)
     std::string lsb = IMMEDIATE(copy(lsb_value));
     std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
-    return img::format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
+    return img_format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
 
 
@@ -5736,7 +5721,7 @@ std::string NMD::DEXT(uint64 instruction)
     std::string lsb = IMMEDIATE(copy(lsb_value));
     std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
-    return img::format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
+    return img_format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
 
 
@@ -5762,7 +5747,7 @@ std::string NMD::DEXTU(uint64 instruction)
     std::string lsb = IMMEDIATE(copy(lsb_value));
     std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
-    return img::format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
+    return img_format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
 
 
@@ -5789,7 +5774,7 @@ std::string NMD::DINSM(uint64 instruction)
     std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
-    return img::format("DINSM %s, %s, %s, %s", rt, rs, pos, size);
+    return img_format("DINSM %s, %s, %s, %s", rt, rs, pos, size);
     /* hand edited */
 }
 
@@ -5817,7 +5802,7 @@ std::string NMD::DINS(uint64 instruction)
     std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
-    return img::format("DINS %s, %s, %s, %s", rt, rs, pos, size);
+    return img_format("DINS %s, %s, %s, %s", rt, rs, pos, size);
     /* hand edited */
 }
 
@@ -5845,7 +5830,7 @@ std::string NMD::DINSU(uint64 instruction)
     std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
-    return img::format("DINSU %s, %s, %s, %s", rt, rs, pos, size);
+    return img_format("DINSU %s, %s, %s, %s", rt, rs, pos, size);
     /* hand edited */
 }
 
@@ -5866,7 +5851,7 @@ std::string NMD::DI(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DI %s", rt);
+    return img_format("DI %s", rt);
 }
 
 
@@ -5890,7 +5875,7 @@ std::string NMD::DIV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DIV %s, %s, %s", rd, rs, rt);
+    return img_format("DIV %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -5914,7 +5899,7 @@ std::string NMD::DIV_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("DIV.D %s, %s, %s", fd, fs, ft);
+    return img_format("DIV.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -5938,7 +5923,7 @@ std::string NMD::DIV_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("DIV.S %s, %s, %s", fd, fs, ft);
+    return img_format("DIV.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -5962,7 +5947,7 @@ std::string NMD::DIVU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DIVU %s, %s, %s", rd, rs, rt);
+    return img_format("DIVU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -5988,7 +5973,7 @@ std::string NMD::DLSA(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u2 = IMMEDIATE(copy(u2_value));
 
-    return img::format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
+    return img_format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
 }
 
 
@@ -6010,7 +5995,7 @@ std::string NMD::DLUI_48_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("DLUI %s, %s", rt, u);
+    return img_format("DLUI %s, %s", rt, u);
 }
 
 
@@ -6034,7 +6019,7 @@ std::string NMD::DMFC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("DMFC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("DMFC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -6056,7 +6041,7 @@ std::string NMD::DMFC1(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("DMFC1 %s, %s", rt, fs);
+    return img_format("DMFC1 %s, %s", rt, fs);
 }
 
 
@@ -6078,7 +6063,7 @@ std::string NMD::DMFC2(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string cs = CPR(copy(cs_value));
 
-    return img::format("DMFC2 %s, %s", rt, cs);
+    return img_format("DMFC2 %s, %s", rt, cs);
 }
 
 
@@ -6102,7 +6087,7 @@ std::string NMD::DMFGC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("DMFGC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("DMFGC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -6126,7 +6111,7 @@ std::string NMD::DMOD(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DMOD %s, %s, %s", rd, rs, rt);
+    return img_format("DMOD %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -6150,7 +6135,7 @@ std::string NMD::DMODU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DMODU %s, %s, %s", rd, rs, rt);
+    return img_format("DMODU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -6174,7 +6159,7 @@ std::string NMD::DMTC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("DMTC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("DMTC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -6196,7 +6181,7 @@ std::string NMD::DMTC1(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("DMTC1 %s, %s", rt, fs);
+    return img_format("DMTC1 %s, %s", rt, fs);
 }
 
 
@@ -6218,7 +6203,7 @@ std::string NMD::DMTC2(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string cs = CPR(copy(cs_value));
 
-    return img::format("DMTC2 %s, %s", rt, cs);
+    return img_format("DMTC2 %s, %s", rt, cs);
 }
 
 
@@ -6242,7 +6227,7 @@ std::string NMD::DMTGC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("DMTGC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("DMTGC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -6262,7 +6247,7 @@ std::string NMD::DMT(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DMT %s", rt);
+    return img_format("DMT %s", rt);
 }
 
 
@@ -6286,7 +6271,7 @@ std::string NMD::DMUH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DMUH %s, %s, %s", rd, rs, rt);
+    return img_format("DMUH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -6310,7 +6295,7 @@ std::string NMD::DMUHU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DMUHU %s, %s, %s", rd, rs, rt);
+    return img_format("DMUHU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -6334,7 +6319,7 @@ std::string NMD::DMUL(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DMUL %s, %s, %s", rd, rs, rt);
+    return img_format("DMUL %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -6358,7 +6343,7 @@ std::string NMD::DMULU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DMULU %s, %s, %s", rd, rs, rt);
+    return img_format("DMULU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -6383,7 +6368,7 @@ std::string NMD::DPA_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPA.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("DPA.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6407,7 +6392,7 @@ std::string NMD::DPAQ_SA_L_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPAQ_SA.L.W %s, %s, %s", ac, rs, rt);
+    return img_format("DPAQ_SA.L.W %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6431,7 +6416,7 @@ std::string NMD::DPAQ_S_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPAQ_S.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("DPAQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6455,7 +6440,7 @@ std::string NMD::DPAQX_SA_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6479,7 +6464,7 @@ std::string NMD::DPAQX_S_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6503,7 +6488,7 @@ std::string NMD::DPAU_H_QBL(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
+    return img_format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6527,7 +6512,7 @@ std::string NMD::DPAU_H_QBR(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
+    return img_format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6551,7 +6536,7 @@ std::string NMD::DPAX_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6575,7 +6560,7 @@ std::string NMD::DPS_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPS.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("DPS.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6599,7 +6584,7 @@ std::string NMD::DPSQ_SA_L_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
+    return img_format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6623,7 +6608,7 @@ std::string NMD::DPSQ_S_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6647,7 +6632,7 @@ std::string NMD::DPSQX_SA_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6671,7 +6656,7 @@ std::string NMD::DPSQX_S_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6695,7 +6680,7 @@ std::string NMD::DPSU_H_QBL(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
+    return img_format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6719,7 +6704,7 @@ std::string NMD::DPSU_H_QBR(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
+    return img_format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6743,7 +6728,7 @@ std::string NMD::DPSX_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -6767,7 +6752,7 @@ std::string NMD::DROTR(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("DROTR %s, %s, %s", rt, rs, shift);
+    return img_format("DROTR %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -6791,7 +6776,7 @@ std::string NMD::DROTR32(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("DROTR32 %s, %s, %s", rt, rs, shift);
+    return img_format("DROTR32 %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -6815,7 +6800,7 @@ std::string NMD::DROTRV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DROTRV %s, %s, %s", rd, rs, rt);
+    return img_format("DROTRV %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -6841,7 +6826,7 @@ std::string NMD::DROTX(uint64 instruction)
     std::string shift = IMMEDIATE(copy(shift_value));
     std::string shiftx = IMMEDIATE(copy(shiftx_value));
 
-    return img::format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
+    return img_format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
 }
 
 
@@ -6865,7 +6850,7 @@ std::string NMD::DSLL(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("DSLL %s, %s, %s", rt, rs, shift);
+    return img_format("DSLL %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -6889,7 +6874,7 @@ std::string NMD::DSLL32(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("DSLL32 %s, %s, %s", rt, rs, shift);
+    return img_format("DSLL32 %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -6913,7 +6898,7 @@ std::string NMD::DSLLV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DSLLV %s, %s, %s", rd, rs, rt);
+    return img_format("DSLLV %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -6937,7 +6922,7 @@ std::string NMD::DSRA(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("DSRA %s, %s, %s", rt, rs, shift);
+    return img_format("DSRA %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -6961,7 +6946,7 @@ std::string NMD::DSRA32(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("DSRA32 %s, %s, %s", rt, rs, shift);
+    return img_format("DSRA32 %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -6985,7 +6970,7 @@ std::string NMD::DSRAV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DSRAV %s, %s, %s", rd, rs, rt);
+    return img_format("DSRAV %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -7009,7 +6994,7 @@ std::string NMD::DSRL(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("DSRL %s, %s, %s", rt, rs, shift);
+    return img_format("DSRL %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -7033,7 +7018,7 @@ std::string NMD::DSRL32(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("DSRL32 %s, %s, %s", rt, rs, shift);
+    return img_format("DSRL32 %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -7057,7 +7042,7 @@ std::string NMD::DSRLV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DSRLV %s, %s, %s", rd, rs, rt);
+    return img_format("DSRLV %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -7081,7 +7066,7 @@ std::string NMD::DSUB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DSUB %s, %s, %s", rd, rs, rt);
+    return img_format("DSUB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -7105,7 +7090,7 @@ std::string NMD::DSUBU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DSUBU %s, %s, %s", rd, rs, rt);
+    return img_format("DSUBU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -7125,7 +7110,7 @@ std::string NMD::DVPE(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DVPE %s", rt);
+    return img_format("DVPE %s", rt);
 }
 
 
@@ -7145,7 +7130,7 @@ std::string NMD::DVP(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("DVP %s", rt);
+    return img_format("DVP %s", rt);
 }
 
 
@@ -7183,7 +7168,7 @@ std::string NMD::EI(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("EI %s", rt);
+    return img_format("EI %s", rt);
 }
 
 
@@ -7203,7 +7188,7 @@ std::string NMD::EMT(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("EMT %s", rt);
+    return img_format("EMT %s", rt);
 }
 
 
@@ -7259,7 +7244,7 @@ std::string NMD::EVP(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("EVP %s", rt);
+    return img_format("EVP %s", rt);
 }
 
 
@@ -7279,7 +7264,7 @@ std::string NMD::EVPE(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("EVPE %s", rt);
+    return img_format("EVPE %s", rt);
 }
 
 
@@ -7305,7 +7290,7 @@ std::string NMD::EXT(uint64 instruction)
     std::string lsb = IMMEDIATE(copy(lsb_value));
     std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
-    return img::format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
+    return img_format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
 
 
@@ -7331,7 +7316,7 @@ std::string NMD::EXTD(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
+    return img_format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
 }
 
 
@@ -7357,7 +7342,7 @@ std::string NMD::EXTD32(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
+    return img_format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
 }
 
 
@@ -7381,7 +7366,7 @@ std::string NMD::EXTPDP(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string size = IMMEDIATE(copy(size_value));
 
-    return img::format("EXTPDP %s, %s, %s", rt, ac, size);
+    return img_format("EXTPDP %s, %s, %s", rt, ac, size);
 }
 
 
@@ -7405,7 +7390,7 @@ std::string NMD::EXTPDPV(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("EXTPDPV %s, %s, %s", rt, ac, rs);
+    return img_format("EXTPDPV %s, %s, %s", rt, ac, rs);
 }
 
 
@@ -7429,7 +7414,7 @@ std::string NMD::EXTP(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string size = IMMEDIATE(copy(size_value));
 
-    return img::format("EXTP %s, %s, %s", rt, ac, size);
+    return img_format("EXTP %s, %s, %s", rt, ac, size);
 }
 
 
@@ -7453,7 +7438,7 @@ std::string NMD::EXTPV(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("EXTPV %s, %s, %s", rt, ac, rs);
+    return img_format("EXTPV %s, %s, %s", rt, ac, rs);
 }
 
 
@@ -7478,7 +7463,7 @@ std::string NMD::EXTR_RS_W(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
+    return img_format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
 }
 
 
@@ -7503,7 +7488,7 @@ std::string NMD::EXTR_R_W(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("EXTR_R.W %s, %s, %s", rt, ac, shift);
+    return img_format("EXTR_R.W %s, %s, %s", rt, ac, shift);
 }
 
 
@@ -7528,7 +7513,7 @@ std::string NMD::EXTR_S_H(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("EXTR_S.H %s, %s, %s", rt, ac, shift);
+    return img_format("EXTR_S.H %s, %s, %s", rt, ac, shift);
 }
 
 
@@ -7553,7 +7538,7 @@ std::string NMD::EXTR_W(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("EXTR.W %s, %s, %s", rt, ac, shift);
+    return img_format("EXTR.W %s, %s, %s", rt, ac, shift);
 }
 
 
@@ -7578,7 +7563,7 @@ std::string NMD::EXTRV_RS_W(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
+    return img_format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
 }
 
 
@@ -7603,7 +7588,7 @@ std::string NMD::EXTRV_R_W(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
+    return img_format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
 }
 
 
@@ -7628,7 +7613,7 @@ std::string NMD::EXTRV_S_H(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
+    return img_format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
 }
 
 
@@ -7653,7 +7638,7 @@ std::string NMD::EXTRV_W(uint64 instruction)
     std::string ac = AC(copy(ac_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("EXTRV.W %s, %s, %s", rt, ac, rs);
+    return img_format("EXTRV.W %s, %s, %s", rt, ac, rs);
 }
 
 
@@ -7680,7 +7665,7 @@ std::string NMD::EXTW(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
+    return img_format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
 }
 
 
@@ -7702,7 +7687,7 @@ std::string NMD::FLOOR_L_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("FLOOR.L.D %s, %s", ft, fs);
+    return img_format("FLOOR.L.D %s, %s", ft, fs);
 }
 
 
@@ -7724,7 +7709,7 @@ std::string NMD::FLOOR_L_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("FLOOR.L.S %s, %s", ft, fs);
+    return img_format("FLOOR.L.S %s, %s", ft, fs);
 }
 
 
@@ -7746,7 +7731,7 @@ std::string NMD::FLOOR_W_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("FLOOR.W.D %s, %s", ft, fs);
+    return img_format("FLOOR.W.D %s, %s", ft, fs);
 }
 
 
@@ -7768,7 +7753,7 @@ std::string NMD::FLOOR_W_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("FLOOR.W.S %s, %s", ft, fs);
+    return img_format("FLOOR.W.S %s, %s", ft, fs);
 }
 
 
@@ -7792,7 +7777,7 @@ std::string NMD::FORK(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("FORK %s, %s, %s", rd, rs, rt);
+    return img_format("FORK %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -7812,7 +7797,7 @@ std::string NMD::HYPCALL(uint64 instruction)
 
     std::string code = IMMEDIATE(copy(code_value));
 
-    return img::format("HYPCALL %s", code);
+    return img_format("HYPCALL %s", code);
 }
 
 
@@ -7832,7 +7817,7 @@ std::string NMD::HYPCALL_16_(uint64 instruction)
 
     std::string code = IMMEDIATE(copy(code_value));
 
-    return img::format("HYPCALL %s", code);
+    return img_format("HYPCALL %s", code);
 }
 
 
@@ -7859,7 +7844,7 @@ std::string NMD::INS(uint64 instruction)
     std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
-    return img::format("INS %s, %s, %s, %s", rt, rs, pos, size);
+    return img_format("INS %s, %s, %s, %s", rt, rs, pos, size);
     /* hand edited */
 }
 
@@ -7881,7 +7866,7 @@ std::string NMD::INSV(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("INSV %s, %s", rt, rs);
+    return img_format("INSV %s, %s", rt, rs);
 }
 
 
@@ -7919,7 +7904,7 @@ std::string NMD::JALRC_16_(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("JALRC $%d, %s", 31, rt);
+    return img_format("JALRC $%d, %s", 31, rt);
 }
 
 
@@ -7941,7 +7926,7 @@ std::string NMD::JALRC_32_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("JALRC %s, %s", rt, rs);
+    return img_format("JALRC %s, %s", rt, rs);
 }
 
 
@@ -7963,7 +7948,7 @@ std::string NMD::JALRC_HB(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("JALRC.HB %s, %s", rt, rs);
+    return img_format("JALRC.HB %s, %s", rt, rs);
 }
 
 
@@ -7983,7 +7968,7 @@ std::string NMD::JRC(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("JRC %s", rt);
+    return img_format("JRC %s", rt);
 }
 
 
@@ -8007,7 +7992,7 @@ std::string NMD::LB_16_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
-    return img::format("LB %s, %s(%s)", rt3, u, rs3);
+    return img_format("LB %s, %s(%s)", rt3, u, rs3);
 }
 
 
@@ -8029,7 +8014,7 @@ std::string NMD::LB_GP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("LB %s, %s($%d)", rt, u, 28);
+    return img_format("LB %s, %s($%d)", rt, u, 28);
 }
 
 
@@ -8053,7 +8038,7 @@ std::string NMD::LB_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LB %s, %s(%s)", rt, s, rs);
+    return img_format("LB %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -8077,7 +8062,7 @@ std::string NMD::LB_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LB %s, %s(%s)", rt, u, rs);
+    return img_format("LB %s, %s(%s)", rt, u, rs);
 }
 
 
@@ -8101,7 +8086,7 @@ std::string NMD::LBE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LBE %s, %s(%s)", rt, s, rs);
+    return img_format("LBE %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -8125,7 +8110,7 @@ std::string NMD::LBU_16_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
-    return img::format("LBU %s, %s(%s)", rt3, u, rs3);
+    return img_format("LBU %s, %s(%s)", rt3, u, rs3);
 }
 
 
@@ -8147,7 +8132,7 @@ std::string NMD::LBU_GP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("LBU %s, %s($%d)", rt, u, 28);
+    return img_format("LBU %s, %s($%d)", rt, u, 28);
 }
 
 
@@ -8171,7 +8156,7 @@ std::string NMD::LBU_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LBU %s, %s(%s)", rt, s, rs);
+    return img_format("LBU %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -8195,7 +8180,7 @@ std::string NMD::LBU_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LBU %s, %s(%s)", rt, u, rs);
+    return img_format("LBU %s, %s(%s)", rt, u, rs);
 }
 
 
@@ -8219,7 +8204,7 @@ std::string NMD::LBUE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LBUE %s, %s(%s)", rt, s, rs);
+    return img_format("LBUE %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -8243,7 +8228,7 @@ std::string NMD::LBUX(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LBUX %s, %s(%s)", rd, rs, rt);
+    return img_format("LBUX %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -8267,7 +8252,7 @@ std::string NMD::LBX(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LBX %s, %s(%s)", rd, rs, rt);
+    return img_format("LBX %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -8289,7 +8274,7 @@ std::string NMD::LD_GP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("LD %s, %s($%d)", rt, u, 28);
+    return img_format("LD %s, %s($%d)", rt, u, 28);
 }
 
 
@@ -8313,7 +8298,7 @@ std::string NMD::LD_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LD %s, %s(%s)", rt, s, rs);
+    return img_format("LD %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -8337,7 +8322,7 @@ std::string NMD::LD_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LD %s, %s(%s)", rt, u, rs);
+    return img_format("LD %s, %s(%s)", rt, u, rs);
 }
 
 
@@ -8359,7 +8344,7 @@ std::string NMD::LDC1_GP_(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("LDC1 %s, %s($%d)", ft, u, 28);
+    return img_format("LDC1 %s, %s($%d)", ft, u, 28);
 }
 
 
@@ -8383,7 +8368,7 @@ std::string NMD::LDC1_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LDC1 %s, %s(%s)", ft, s, rs);
+    return img_format("LDC1 %s, %s(%s)", ft, s, rs);
 }
 
 
@@ -8407,7 +8392,7 @@ std::string NMD::LDC1_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LDC1 %s, %s(%s)", ft, u, rs);
+    return img_format("LDC1 %s, %s(%s)", ft, u, rs);
 }
 
 
@@ -8431,7 +8416,7 @@ std::string NMD::LDC1XS(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LDC1XS %s, %s(%s)", ft, rs, rt);
+    return img_format("LDC1XS %s, %s(%s)", ft, rs, rt);
 }
 
 
@@ -8455,7 +8440,7 @@ std::string NMD::LDC1X(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LDC1X %s, %s(%s)", ft, rs, rt);
+    return img_format("LDC1X %s, %s(%s)", ft, rs, rt);
 }
 
 
@@ -8479,7 +8464,7 @@ std::string NMD::LDC2(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LDC2 %s, %s(%s)", ct, s, rs);
+    return img_format("LDC2 %s, %s(%s)", ct, s, rs);
 }
 
 
@@ -8505,7 +8490,7 @@ std::string NMD::LDM(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img::format("LDM %s, %s(%s), %s", rt, s, rs, count3);
+    return img_format("LDM %s, %s(%s), %s", rt, s, rs, count3);
 }
 
 
@@ -8527,7 +8512,7 @@ std::string NMD::LDPC_48_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 6);
 
-    return img::format("LDPC %s, %s", rt, s);
+    return img_format("LDPC %s, %s", rt, s);
 }
 
 
@@ -8551,7 +8536,7 @@ std::string NMD::LDX(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LDX %s, %s(%s)", rd, rs, rt);
+    return img_format("LDX %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -8575,7 +8560,7 @@ std::string NMD::LDXS(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LDXS %s, %s(%s)", rd, rs, rt);
+    return img_format("LDXS %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -8599,7 +8584,7 @@ std::string NMD::LH_16_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
-    return img::format("LH %s, %s(%s)", rt3, u, rs3);
+    return img_format("LH %s, %s(%s)", rt3, u, rs3);
 }
 
 
@@ -8621,7 +8606,7 @@ std::string NMD::LH_GP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("LH %s, %s($%d)", rt, u, 28);
+    return img_format("LH %s, %s($%d)", rt, u, 28);
 }
 
 
@@ -8645,7 +8630,7 @@ std::string NMD::LH_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LH %s, %s(%s)", rt, s, rs);
+    return img_format("LH %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -8669,7 +8654,7 @@ std::string NMD::LH_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LH %s, %s(%s)", rt, u, rs);
+    return img_format("LH %s, %s(%s)", rt, u, rs);
 }
 
 
@@ -8693,7 +8678,7 @@ std::string NMD::LHE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LHE %s, %s(%s)", rt, s, rs);
+    return img_format("LHE %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -8717,7 +8702,7 @@ std::string NMD::LHU_16_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
-    return img::format("LHU %s, %s(%s)", rt3, u, rs3);
+    return img_format("LHU %s, %s(%s)", rt3, u, rs3);
 }
 
 
@@ -8739,7 +8724,7 @@ std::string NMD::LHU_GP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("LHU %s, %s($%d)", rt, u, 28);
+    return img_format("LHU %s, %s($%d)", rt, u, 28);
 }
 
 
@@ -8763,7 +8748,7 @@ std::string NMD::LHU_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LHU %s, %s(%s)", rt, s, rs);
+    return img_format("LHU %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -8787,7 +8772,7 @@ std::string NMD::LHU_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LHU %s, %s(%s)", rt, u, rs);
+    return img_format("LHU %s, %s(%s)", rt, u, rs);
 }
 
 
@@ -8811,7 +8796,7 @@ std::string NMD::LHUE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LHUE %s, %s(%s)", rt, s, rs);
+    return img_format("LHUE %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -8835,7 +8820,7 @@ std::string NMD::LHUX(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LHUX %s, %s(%s)", rd, rs, rt);
+    return img_format("LHUX %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -8859,7 +8844,7 @@ std::string NMD::LHUXS(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LHUXS %s, %s(%s)", rd, rs, rt);
+    return img_format("LHUXS %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -8883,7 +8868,7 @@ std::string NMD::LHXS(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LHXS %s, %s(%s)", rd, rs, rt);
+    return img_format("LHXS %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -8907,7 +8892,7 @@ std::string NMD::LHX(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LHX %s, %s(%s)", rd, rs, rt);
+    return img_format("LHX %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -8929,7 +8914,7 @@ std::string NMD::LI_16_(uint64 instruction)
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
     std::string eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
 
-    return img::format("LI %s, %s", rt3, eu);
+    return img_format("LI %s, %s", rt3, eu);
 }
 
 
@@ -8951,7 +8936,7 @@ std::string NMD::LI_48_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = IMMEDIATE(copy(s_value));
 
-    return img::format("LI %s, %s", rt, s);
+    return img_format("LI %s, %s", rt, s);
 }
 
 
@@ -8975,7 +8960,7 @@ std::string NMD::LL(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LL %s, %s(%s)", rt, s, rs);
+    return img_format("LL %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -8999,7 +8984,7 @@ std::string NMD::LLD(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LLD %s, %s(%s)", rt, s, rs);
+    return img_format("LLD %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -9023,7 +9008,7 @@ std::string NMD::LLDP(uint64 instruction)
     std::string ru = GPR(copy(ru_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LLDP %s, %s, (%s)", rt, ru, rs);
+    return img_format("LLDP %s, %s, (%s)", rt, ru, rs);
 }
 
 
@@ -9047,7 +9032,7 @@ std::string NMD::LLE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LLE %s, %s(%s)", rt, s, rs);
+    return img_format("LLE %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -9071,7 +9056,7 @@ std::string NMD::LLWP(uint64 instruction)
     std::string ru = GPR(copy(ru_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LLWP %s, %s, (%s)", rt, ru, rs);
+    return img_format("LLWP %s, %s, (%s)", rt, ru, rs);
 }
 
 
@@ -9095,7 +9080,7 @@ std::string NMD::LLWPE(uint64 instruction)
     std::string ru = GPR(copy(ru_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LLWPE %s, %s, (%s)", rt, ru, rs);
+    return img_format("LLWPE %s, %s, (%s)", rt, ru, rs);
 }
 
 
@@ -9121,7 +9106,7 @@ std::string NMD::LSA(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u2 = IMMEDIATE(copy(u2_value));
 
-    return img::format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
+    return img_format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
 }
 
 
@@ -9143,7 +9128,7 @@ std::string NMD::LUI(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = IMMEDIATE(copy(s_value));
 
-    return img::format("LUI %s, %%hi(%s)", rt, s);
+    return img_format("LUI %s, %%hi(%s)", rt, s);
 }
 
 
@@ -9167,7 +9152,7 @@ std::string NMD::LW_16_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
-    return img::format("LW %s, %s(%s)", rt3, u, rs3);
+    return img_format("LW %s, %s(%s)", rt3, u, rs3);
 }
 
 
@@ -9191,7 +9176,7 @@ std::string NMD::LW_4X4_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
 
-    return img::format("LW %s, %s(%s)", rt4, u, rs4);
+    return img_format("LW %s, %s(%s)", rt4, u, rs4);
 }
 
 
@@ -9213,7 +9198,7 @@ std::string NMD::LW_GP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("LW %s, %s($%d)", rt, u, 28);
+    return img_format("LW %s, %s($%d)", rt, u, 28);
 }
 
 
@@ -9235,7 +9220,7 @@ std::string NMD::LW_GP16_(uint64 instruction)
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("LW %s, %s($%d)", rt3, u, 28);
+    return img_format("LW %s, %s($%d)", rt3, u, 28);
 }
 
 
@@ -9259,7 +9244,7 @@ std::string NMD::LW_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LW %s, %s(%s)", rt, s, rs);
+    return img_format("LW %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -9281,7 +9266,7 @@ std::string NMD::LW_SP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("LW %s, %s($%d)", rt, u, 29);
+    return img_format("LW %s, %s($%d)", rt, u, 29);
 }
 
 
@@ -9305,7 +9290,7 @@ std::string NMD::LW_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LW %s, %s(%s)", rt, u, rs);
+    return img_format("LW %s, %s(%s)", rt, u, rs);
 }
 
 
@@ -9327,7 +9312,7 @@ std::string NMD::LWC1_GP_(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("LWC1 %s, %s($%d)", ft, u, 28);
+    return img_format("LWC1 %s, %s($%d)", ft, u, 28);
 }
 
 
@@ -9351,7 +9336,7 @@ std::string NMD::LWC1_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LWC1 %s, %s(%s)", ft, s, rs);
+    return img_format("LWC1 %s, %s(%s)", ft, s, rs);
 }
 
 
@@ -9375,7 +9360,7 @@ std::string NMD::LWC1_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LWC1 %s, %s(%s)", ft, u, rs);
+    return img_format("LWC1 %s, %s(%s)", ft, u, rs);
 }
 
 
@@ -9399,7 +9384,7 @@ std::string NMD::LWC1X(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LWC1X %s, %s(%s)", ft, rs, rt);
+    return img_format("LWC1X %s, %s(%s)", ft, rs, rt);
 }
 
 
@@ -9423,7 +9408,7 @@ std::string NMD::LWC1XS(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LWC1XS %s, %s(%s)", ft, rs, rt);
+    return img_format("LWC1XS %s, %s(%s)", ft, rs, rt);
 }
 
 
@@ -9447,7 +9432,7 @@ std::string NMD::LWC2(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LWC2 %s, %s(%s)", ct, s, rs);
+    return img_format("LWC2 %s, %s(%s)", ct, s, rs);
 }
 
 
@@ -9471,7 +9456,7 @@ std::string NMD::LWE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LWE %s, %s(%s)", rt, s, rs);
+    return img_format("LWE %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -9497,7 +9482,7 @@ std::string NMD::LWM(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img::format("LWM %s, %s(%s), %s", rt, s, rs, count3);
+    return img_format("LWM %s, %s(%s), %s", rt, s, rs, count3);
 }
 
 
@@ -9519,7 +9504,7 @@ std::string NMD::LWPC_48_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 6);
 
-    return img::format("LWPC %s, %s", rt, s);
+    return img_format("LWPC %s, %s", rt, s);
 }
 
 
@@ -9541,7 +9526,7 @@ std::string NMD::LWU_GP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("LWU %s, %s($%d)", rt, u, 28);
+    return img_format("LWU %s, %s($%d)", rt, u, 28);
 }
 
 
@@ -9565,7 +9550,7 @@ std::string NMD::LWU_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LWU %s, %s(%s)", rt, s, rs);
+    return img_format("LWU %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -9589,7 +9574,7 @@ std::string NMD::LWU_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("LWU %s, %s(%s)", rt, u, rs);
+    return img_format("LWU %s, %s(%s)", rt, u, rs);
 }
 
 
@@ -9613,7 +9598,7 @@ std::string NMD::LWUX(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LWUX %s, %s(%s)", rd, rs, rt);
+    return img_format("LWUX %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -9637,7 +9622,7 @@ std::string NMD::LWUXS(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LWUXS %s, %s(%s)", rd, rs, rt);
+    return img_format("LWUXS %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -9661,7 +9646,7 @@ std::string NMD::LWX(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LWX %s, %s(%s)", rd, rs, rt);
+    return img_format("LWX %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -9685,7 +9670,7 @@ std::string NMD::LWXS_16_(uint64 instruction)
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
     std::string rt3 = IMMEDIATE(decode_gpr_gpr3(rt3_value));
 
-    return img::format("LWXS %s, %s(%s)", rd3, rs3, rt3);
+    return img_format("LWXS %s, %s(%s)", rd3, rs3, rt3);
 }
 
 
@@ -9709,7 +9694,7 @@ std::string NMD::LWXS_32_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("LWXS %s, %s(%s)", rd, rs, rt);
+    return img_format("LWXS %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -9734,7 +9719,7 @@ std::string NMD::MADD_DSP_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MADD %s, %s, %s", ac, rs, rt);
+    return img_format("MADD %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -9758,7 +9743,7 @@ std::string NMD::MADDF_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MADDF.D %s, %s, %s", fd, fs, ft);
+    return img_format("MADDF.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -9782,7 +9767,7 @@ std::string NMD::MADDF_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MADDF.S %s, %s, %s", fd, fs, ft);
+    return img_format("MADDF.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -9807,7 +9792,7 @@ std::string NMD::MADDU_DSP_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MADDU %s, %s, %s", ac, rs, rt);
+    return img_format("MADDU %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -9832,7 +9817,7 @@ std::string NMD::MAQ_S_W_PHL(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
+    return img_format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -9857,7 +9842,7 @@ std::string NMD::MAQ_S_W_PHR(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
+    return img_format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -9882,7 +9867,7 @@ std::string NMD::MAQ_SA_W_PHL(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
+    return img_format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -9907,7 +9892,7 @@ std::string NMD::MAQ_SA_W_PHR(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
+    return img_format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -9931,7 +9916,7 @@ std::string NMD::MAX_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MAX.D %s, %s, %s", fd, fs, ft);
+    return img_format("MAX.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -9955,7 +9940,7 @@ std::string NMD::MAX_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MAX.S %s, %s, %s", fd, fs, ft);
+    return img_format("MAX.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -9979,7 +9964,7 @@ std::string NMD::MAXA_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MAXA.D %s, %s, %s", fd, fs, ft);
+    return img_format("MAXA.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -10003,7 +9988,7 @@ std::string NMD::MAXA_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MAXA.S %s, %s, %s", fd, fs, ft);
+    return img_format("MAXA.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -10027,7 +10012,7 @@ std::string NMD::MFC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MFC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("MFC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -10049,7 +10034,7 @@ std::string NMD::MFC1(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("MFC1 %s, %s", rt, fs);
+    return img_format("MFC1 %s, %s", rt, fs);
 }
 
 
@@ -10071,7 +10056,7 @@ std::string NMD::MFC2(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string cs = CPR(copy(cs_value));
 
-    return img::format("MFC2 %s, %s", rt, cs);
+    return img_format("MFC2 %s, %s", rt, cs);
 }
 
 
@@ -10095,7 +10080,7 @@ std::string NMD::MFGC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MFGC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("MFGC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -10119,7 +10104,7 @@ std::string NMD::MFHC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MFHC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("MFHC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -10141,7 +10126,7 @@ std::string NMD::MFHC1(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("MFHC1 %s, %s", rt, fs);
+    return img_format("MFHC1 %s, %s", rt, fs);
 }
 
 
@@ -10163,7 +10148,7 @@ std::string NMD::MFHC2(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string cs = CPR(copy(cs_value));
 
-    return img::format("MFHC2 %s, %s", rt, cs);
+    return img_format("MFHC2 %s, %s", rt, cs);
 }
 
 
@@ -10187,7 +10172,7 @@ std::string NMD::MFHGC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MFHGC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("MFHGC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -10208,7 +10193,7 @@ std::string NMD::MFHI_DSP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string ac = AC(copy(ac_value));
 
-    return img::format("MFHI %s, %s", rt, ac);
+    return img_format("MFHI %s, %s", rt, ac);
 }
 
 
@@ -10234,7 +10219,7 @@ std::string NMD::MFHTR(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
+    return img_format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
 
 
@@ -10255,7 +10240,7 @@ std::string NMD::MFLO_DSP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string ac = AC(copy(ac_value));
 
-    return img::format("MFLO %s, %s", rt, ac);
+    return img_format("MFLO %s, %s", rt, ac);
 }
 
 
@@ -10281,7 +10266,7 @@ std::string NMD::MFTR(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
+    return img_format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
 
 
@@ -10305,7 +10290,7 @@ std::string NMD::MIN_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MIN.D %s, %s, %s", fd, fs, ft);
+    return img_format("MIN.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -10329,7 +10314,7 @@ std::string NMD::MIN_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MIN.S %s, %s, %s", fd, fs, ft);
+    return img_format("MIN.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -10353,7 +10338,7 @@ std::string NMD::MINA_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MINA.D %s, %s, %s", fd, fs, ft);
+    return img_format("MINA.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -10377,7 +10362,7 @@ std::string NMD::MINA_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MINA.S %s, %s, %s", fd, fs, ft);
+    return img_format("MINA.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -10401,7 +10386,7 @@ std::string NMD::MOD(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MOD %s, %s, %s", rd, rs, rt);
+    return img_format("MOD %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -10425,7 +10410,7 @@ std::string NMD::MODSUB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MODSUB %s, %s, %s", rd, rs, rt);
+    return img_format("MODSUB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -10449,7 +10434,7 @@ std::string NMD::MODU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MODU %s, %s, %s", rd, rs, rt);
+    return img_format("MODU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -10471,7 +10456,7 @@ std::string NMD::MOV_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("MOV.D %s, %s", ft, fs);
+    return img_format("MOV.D %s, %s", ft, fs);
 }
 
 
@@ -10493,7 +10478,7 @@ std::string NMD::MOV_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("MOV.S %s, %s", ft, fs);
+    return img_format("MOV.S %s, %s", ft, fs);
 }
 
 
@@ -10517,7 +10502,7 @@ std::string NMD::MOVE_BALC(uint64 instruction)
     std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img::format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
+    return img_format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
 }
 
 
@@ -10543,7 +10528,7 @@ std::string NMD::MOVEP(uint64 instruction)
     std::string rsz4 = GPR(decode_gpr_gpr4_zero(rsz4_value));
     std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
 
-    return img::format("MOVEP %s, %s, %s, %s", rd2, re2, rsz4, rtz4);
+    return img_format("MOVEP %s, %s, %s, %s", rd2, re2, rsz4, rtz4);
     /* hand edited */
 }
 
@@ -10570,7 +10555,7 @@ std::string NMD::MOVEP_REV_(uint64 instruction)
     std::string rs2 = GPR(decode_gpr_gpr2_reg2(rd2_value));
     /* !!!!!!!!!! - no conversion function */
 
-    return img::format("MOVEP %s, %s, %s, %s", rs4, rt4, rd2, rs2);
+    return img_format("MOVEP %s, %s, %s, %s", rs4, rt4, rd2, rs2);
     /* hand edited */
 }
 
@@ -10593,7 +10578,7 @@ std::string NMD::MOVE(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("MOVE %s, %s", rt, rs);
+    return img_format("MOVE %s, %s", rt, rs);
 }
 
 
@@ -10617,7 +10602,7 @@ std::string NMD::MOVN(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MOVN %s, %s, %s", rd, rs, rt);
+    return img_format("MOVN %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -10641,7 +10626,7 @@ std::string NMD::MOVZ(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MOVZ %s, %s, %s", rd, rs, rt);
+    return img_format("MOVZ %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -10665,7 +10650,7 @@ std::string NMD::MSUB_DSP_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MSUB %s, %s, %s", ac, rs, rt);
+    return img_format("MSUB %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -10689,7 +10674,7 @@ std::string NMD::MSUBF_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MSUBF.D %s, %s, %s", fd, fs, ft);
+    return img_format("MSUBF.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -10713,7 +10698,7 @@ std::string NMD::MSUBF_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MSUBF.S %s, %s, %s", fd, fs, ft);
+    return img_format("MSUBF.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -10737,7 +10722,7 @@ std::string NMD::MSUBU_DSP_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MSUBU %s, %s, %s", ac, rs, rt);
+    return img_format("MSUBU %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -10761,7 +10746,7 @@ std::string NMD::MTC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MTC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("MTC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -10783,7 +10768,7 @@ std::string NMD::MTC1(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("MTC1 %s, %s", rt, fs);
+    return img_format("MTC1 %s, %s", rt, fs);
 }
 
 
@@ -10805,7 +10790,7 @@ std::string NMD::MTC2(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string cs = CPR(copy(cs_value));
 
-    return img::format("MTC2 %s, %s", rt, cs);
+    return img_format("MTC2 %s, %s", rt, cs);
 }
 
 
@@ -10829,7 +10814,7 @@ std::string NMD::MTGC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MTGC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("MTGC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -10853,7 +10838,7 @@ std::string NMD::MTHC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MTHC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("MTHC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -10875,7 +10860,7 @@ std::string NMD::MTHC1(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("MTHC1 %s, %s", rt, fs);
+    return img_format("MTHC1 %s, %s", rt, fs);
 }
 
 
@@ -10897,7 +10882,7 @@ std::string NMD::MTHC2(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string cs = CPR(copy(cs_value));
 
-    return img::format("MTHC2 %s, %s", rt, cs);
+    return img_format("MTHC2 %s, %s", rt, cs);
 }
 
 
@@ -10921,7 +10906,7 @@ std::string NMD::MTHGC0(uint64 instruction)
     std::string c0s = CPR(copy(c0s_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MTHGC0 %s, %s, %s", rt, c0s, sel);
+    return img_format("MTHGC0 %s, %s, %s", rt, c0s, sel);
 }
 
 
@@ -10942,7 +10927,7 @@ std::string NMD::MTHI_DSP_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string ac = AC(copy(ac_value));
 
-    return img::format("MTHI %s, %s", rs, ac);
+    return img_format("MTHI %s, %s", rs, ac);
 }
 
 
@@ -10963,7 +10948,7 @@ std::string NMD::MTHLIP(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string ac = AC(copy(ac_value));
 
-    return img::format("MTHLIP %s, %s", rs, ac);
+    return img_format("MTHLIP %s, %s", rs, ac);
 }
 
 
@@ -10989,7 +10974,7 @@ std::string NMD::MTHTR(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
+    return img_format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
 
 
@@ -11010,7 +10995,7 @@ std::string NMD::MTLO_DSP_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string ac = AC(copy(ac_value));
 
-    return img::format("MTLO %s, %s", rs, ac);
+    return img_format("MTLO %s, %s", rs, ac);
 }
 
 
@@ -11036,7 +11021,7 @@ std::string NMD::MTTR(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
+    return img_format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
 
 
@@ -11060,7 +11045,7 @@ std::string NMD::MUH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MUH %s, %s, %s", rd, rs, rt);
+    return img_format("MUH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11084,7 +11069,7 @@ std::string NMD::MUHU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MUHU %s, %s, %s", rd, rs, rt);
+    return img_format("MUHU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11108,7 +11093,7 @@ std::string NMD::MUL_32_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MUL %s, %s, %s", rd, rs, rt);
+    return img_format("MUL %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11130,7 +11115,7 @@ std::string NMD::MUL_4X4_(uint64 instruction)
     std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
     std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
 
-    return img::format("MUL %s, %s", rs4, rt4);
+    return img_format("MUL %s, %s", rs4, rt4);
 }
 
 
@@ -11154,7 +11139,7 @@ std::string NMD::MUL_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MUL.D %s, %s, %s", fd, fs, ft);
+    return img_format("MUL.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -11179,7 +11164,7 @@ std::string NMD::MUL_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MUL.PH %s, %s, %s", rd, rs, rt);
+    return img_format("MUL.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11204,7 +11189,7 @@ std::string NMD::MUL_S_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MUL_S.PH %s, %s, %s", rd, rs, rt);
+    return img_format("MUL_S.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11228,7 +11213,7 @@ std::string NMD::MUL_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("MUL.S %s, %s, %s", fd, fs, ft);
+    return img_format("MUL.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -11253,7 +11238,7 @@ std::string NMD::MULEQ_S_W_PHL(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
+    return img_format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11278,7 +11263,7 @@ std::string NMD::MULEQ_S_W_PHR(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
+    return img_format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11303,7 +11288,7 @@ std::string NMD::MULEU_S_PH_QBL(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
+    return img_format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11328,7 +11313,7 @@ std::string NMD::MULEU_S_PH_QBR(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
+    return img_format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11353,7 +11338,7 @@ std::string NMD::MULQ_RS_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
+    return img_format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11378,7 +11363,7 @@ std::string NMD::MULQ_RS_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
+    return img_format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11403,7 +11388,7 @@ std::string NMD::MULQ_S_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
+    return img_format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11428,7 +11413,7 @@ std::string NMD::MULQ_S_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULQ_S.W %s, %s, %s", rd, rs, rt);
+    return img_format("MULQ_S.W %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11453,7 +11438,7 @@ std::string NMD::MULSA_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -11478,7 +11463,7 @@ std::string NMD::MULSAQ_S_W_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
+    return img_format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -11502,7 +11487,7 @@ std::string NMD::MULT_DSP_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULT %s, %s, %s", ac, rs, rt);
+    return img_format("MULT %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -11526,7 +11511,7 @@ std::string NMD::MULTU_DSP_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULTU %s, %s, %s", ac, rs, rt);
+    return img_format("MULTU %s, %s, %s", ac, rs, rt);
 }
 
 
@@ -11550,7 +11535,7 @@ std::string NMD::MULU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("MULU %s, %s, %s", rd, rs, rt);
+    return img_format("MULU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11572,7 +11557,7 @@ std::string NMD::NEG_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("NEG.D %s, %s", ft, fs);
+    return img_format("NEG.D %s, %s", ft, fs);
 }
 
 
@@ -11594,7 +11579,7 @@ std::string NMD::NEG_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("NEG.S %s, %s", ft, fs);
+    return img_format("NEG.S %s, %s", ft, fs);
 }
 
 
@@ -11654,7 +11639,7 @@ std::string NMD::NOR(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("NOR %s, %s, %s", rd, rs, rt);
+    return img_format("NOR %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11676,7 +11661,7 @@ std::string NMD::NOT_16_(uint64 instruction)
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
-    return img::format("NOT %s, %s", rt3, rs3);
+    return img_format("NOT %s, %s", rt3, rs3);
 }
 
 
@@ -11698,7 +11683,7 @@ std::string NMD::OR_16_(uint64 instruction)
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
 
-    return img::format("OR %s, %s", rs3, rt3);
+    return img_format("OR %s, %s", rs3, rt3);
 }
 
 
@@ -11722,7 +11707,7 @@ std::string NMD::OR_32_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("OR %s, %s, %s", rd, rs, rt);
+    return img_format("OR %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11746,7 +11731,7 @@ std::string NMD::ORI(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("ORI %s, %s, %s", rt, rs, u);
+    return img_format("ORI %s, %s, %s", rt, rs, u);
 }
 
 
@@ -11771,7 +11756,7 @@ std::string NMD::PACKRL_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("PACKRL.PH %s, %s, %s", rd, rs, rt);
+    return img_format("PACKRL.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11814,7 +11799,7 @@ std::string NMD::PICK_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("PICK.PH %s, %s, %s", rd, rs, rt);
+    return img_format("PICK.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11839,7 +11824,7 @@ std::string NMD::PICK_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("PICK.QB %s, %s, %s", rd, rs, rt);
+    return img_format("PICK.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -11862,7 +11847,7 @@ std::string NMD::PRECEQ_W_PHL(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PRECEQ.W.PHL %s, %s", rt, rs);
+    return img_format("PRECEQ.W.PHL %s, %s", rt, rs);
 }
 
 
@@ -11885,7 +11870,7 @@ std::string NMD::PRECEQ_W_PHR(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PRECEQ.W.PHR %s, %s", rt, rs);
+    return img_format("PRECEQ.W.PHR %s, %s", rt, rs);
 }
 
 
@@ -11908,7 +11893,7 @@ std::string NMD::PRECEQU_PH_QBLA(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PRECEQU.PH.QBLA %s, %s", rt, rs);
+    return img_format("PRECEQU.PH.QBLA %s, %s", rt, rs);
 }
 
 
@@ -11931,7 +11916,7 @@ std::string NMD::PRECEQU_PH_QBL(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PRECEQU.PH.QBL %s, %s", rt, rs);
+    return img_format("PRECEQU.PH.QBL %s, %s", rt, rs);
 }
 
 
@@ -11954,7 +11939,7 @@ std::string NMD::PRECEQU_PH_QBRA(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PRECEQU.PH.QBRA %s, %s", rt, rs);
+    return img_format("PRECEQU.PH.QBRA %s, %s", rt, rs);
 }
 
 
@@ -11977,7 +11962,7 @@ std::string NMD::PRECEQU_PH_QBR(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PRECEQU.PH.QBR %s, %s", rt, rs);
+    return img_format("PRECEQU.PH.QBR %s, %s", rt, rs);
 }
 
 
@@ -12001,7 +11986,7 @@ std::string NMD::PRECEU_PH_QBLA(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PRECEU.PH.QBLA %s, %s", rt, rs);
+    return img_format("PRECEU.PH.QBLA %s, %s", rt, rs);
 }
 
 
@@ -12024,7 +12009,7 @@ std::string NMD::PRECEU_PH_QBL(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PRECEU.PH.QBL %s, %s", rt, rs);
+    return img_format("PRECEU.PH.QBL %s, %s", rt, rs);
 }
 
 
@@ -12048,7 +12033,7 @@ std::string NMD::PRECEU_PH_QBRA(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PRECEU.PH.QBRA %s, %s", rt, rs);
+    return img_format("PRECEU.PH.QBRA %s, %s", rt, rs);
 }
 
 
@@ -12071,7 +12056,7 @@ std::string NMD::PRECEU_PH_QBR(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PRECEU.PH.QBR %s, %s", rt, rs);
+    return img_format("PRECEU.PH.QBR %s, %s", rt, rs);
 }
 
 
@@ -12096,7 +12081,7 @@ std::string NMD::PRECR_QB_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
+    return img_format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -12121,7 +12106,7 @@ std::string NMD::PRECR_SRA_PH_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
+    return img_format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -12146,7 +12131,7 @@ std::string NMD::PRECR_SRA_R_PH_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
+    return img_format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -12171,7 +12156,7 @@ std::string NMD::PRECRQ_PH_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
+    return img_format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -12196,7 +12181,7 @@ std::string NMD::PRECRQ_QB_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
+    return img_format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -12221,7 +12206,7 @@ std::string NMD::PRECRQ_RS_PH_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
+    return img_format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -12246,7 +12231,7 @@ std::string NMD::PRECRQU_S_QB_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
+    return img_format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -12270,7 +12255,7 @@ std::string NMD::PREF_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PREF %s, %s(%s)", hint, s, rs);
+    return img_format("PREF %s, %s(%s)", hint, s, rs);
 }
 
 
@@ -12294,7 +12279,7 @@ std::string NMD::PREF_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PREF %s, %s(%s)", hint, u, rs);
+    return img_format("PREF %s, %s(%s)", hint, u, rs);
 }
 
 
@@ -12318,7 +12303,7 @@ std::string NMD::PREFE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("PREFE %s, %s(%s)", hint, s, rs);
+    return img_format("PREFE %s, %s(%s)", hint, s, rs);
 }
 
 
@@ -12342,7 +12327,7 @@ std::string NMD::PREPEND(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("PREPEND %s, %s, %s", rt, rs, sa);
+    return img_format("PREPEND %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -12363,7 +12348,7 @@ std::string NMD::RADDU_W_QB(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("RADDU.W.QB %s, %s", rt, rs);
+    return img_format("RADDU.W.QB %s, %s", rt, rs);
 }
 
 
@@ -12384,7 +12369,7 @@ std::string NMD::RDDSP(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string mask = IMMEDIATE(copy(mask_value));
 
-    return img::format("RDDSP %s, %s", rt, mask);
+    return img_format("RDDSP %s, %s", rt, mask);
 }
 
 
@@ -12408,7 +12393,7 @@ std::string NMD::RDHWR(uint64 instruction)
     std::string hs = CPR(copy(hs_value));
     std::string sel = IMMEDIATE(copy(sel_value));
 
-    return img::format("RDHWR %s, %s, %s", rt, hs, sel);
+    return img_format("RDHWR %s, %s, %s", rt, hs, sel);
 }
 
 
@@ -12430,7 +12415,7 @@ std::string NMD::RDPGPR(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("RDPGPR %s, %s", rt, rs);
+    return img_format("RDPGPR %s, %s", rt, rs);
 }
 
 
@@ -12452,7 +12437,7 @@ std::string NMD::RECIP_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("RECIP.D %s, %s", ft, fs);
+    return img_format("RECIP.D %s, %s", ft, fs);
 }
 
 
@@ -12474,7 +12459,7 @@ std::string NMD::RECIP_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("RECIP.S %s, %s", ft, fs);
+    return img_format("RECIP.S %s, %s", ft, fs);
 }
 
 
@@ -12496,7 +12481,7 @@ std::string NMD::REPL_PH(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = IMMEDIATE(copy(s_value));
 
-    return img::format("REPL.PH %s, %s", rt, s);
+    return img_format("REPL.PH %s, %s", rt, s);
 }
 
 
@@ -12518,7 +12503,7 @@ std::string NMD::REPL_QB(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("REPL.QB %s, %s", rt, u);
+    return img_format("REPL.QB %s, %s", rt, u);
 }
 
 
@@ -12540,7 +12525,7 @@ std::string NMD::REPLV_PH(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("REPLV.PH %s, %s", rt, rs);
+    return img_format("REPLV.PH %s, %s", rt, rs);
 }
 
 
@@ -12561,7 +12546,7 @@ std::string NMD::REPLV_QB(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("REPLV.QB %s, %s", rt, rs);
+    return img_format("REPLV.QB %s, %s", rt, rs);
 }
 
 
@@ -12583,7 +12568,7 @@ std::string NMD::RESTORE_32_(uint64 instruction)
     uint64 gp_value = extract_gp_2(instruction);
 
     std::string u = IMMEDIATE(copy(u_value));
-    return img::format("RESTORE %s%s", u,
+    return img_format("RESTORE %s%s", u,
                save_restore_list(rt_value, count_value, gp_value));
 }
 
@@ -12605,7 +12590,7 @@ std::string NMD::RESTORE_JRC_16_(uint64 instruction)
     uint64 count_value = extract_count_3_2_1_0(instruction);
 
     std::string u = IMMEDIATE(copy(u_value));
-    return img::format("RESTORE.JRC %s%s", u,
+    return img_format("RESTORE.JRC %s%s", u,
         save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
 }
 
@@ -12628,7 +12613,7 @@ std::string NMD::RESTORE_JRC_32_(uint64 instruction)
     uint64 gp_value = extract_gp_2(instruction);
 
     std::string u = IMMEDIATE(copy(u_value));
-    return img::format("RESTORE.JRC %s%s", u,
+    return img_format("RESTORE.JRC %s%s", u,
                save_restore_list(rt_value, count_value, gp_value));
 }
 
@@ -12651,7 +12636,7 @@ std::string NMD::RESTOREF(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string count = IMMEDIATE(copy(count_value));
 
-    return img::format("RESTOREF %s, %s", u, count);
+    return img_format("RESTOREF %s, %s", u, count);
 }
 
 
@@ -12673,7 +12658,7 @@ std::string NMD::RINT_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("RINT.D %s, %s", ft, fs);
+    return img_format("RINT.D %s, %s", ft, fs);
 }
 
 
@@ -12695,7 +12680,7 @@ std::string NMD::RINT_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("RINT.S %s, %s", ft, fs);
+    return img_format("RINT.S %s, %s", ft, fs);
 }
 
 
@@ -12719,7 +12704,7 @@ std::string NMD::ROTR(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("ROTR %s, %s, %s", rt, rs, shift);
+    return img_format("ROTR %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -12743,7 +12728,7 @@ std::string NMD::ROTRV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("ROTRV %s, %s, %s", rd, rs, rt);
+    return img_format("ROTRV %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -12771,7 +12756,7 @@ std::string NMD::ROTX(uint64 instruction)
     std::string shiftx = IMMEDIATE(copy(shiftx_value));
     std::string stripe = IMMEDIATE(copy(stripe_value));
 
-    return img::format("ROTX %s, %s, %s, %s, %s",
+    return img_format("ROTX %s, %s, %s, %s, %s",
                        rt, rs, shift, shiftx, stripe);
 }
 
@@ -12794,7 +12779,7 @@ std::string NMD::ROUND_L_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("ROUND.L.D %s, %s", ft, fs);
+    return img_format("ROUND.L.D %s, %s", ft, fs);
 }
 
 
@@ -12816,7 +12801,7 @@ std::string NMD::ROUND_L_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("ROUND.L.S %s, %s", ft, fs);
+    return img_format("ROUND.L.S %s, %s", ft, fs);
 }
 
 
@@ -12838,7 +12823,7 @@ std::string NMD::ROUND_W_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("ROUND.W.D %s, %s", ft, fs);
+    return img_format("ROUND.W.D %s, %s", ft, fs);
 }
 
 
@@ -12860,7 +12845,7 @@ std::string NMD::ROUND_W_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("ROUND.W.S %s, %s", ft, fs);
+    return img_format("ROUND.W.S %s, %s", ft, fs);
 }
 
 
@@ -12882,7 +12867,7 @@ std::string NMD::RSQRT_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("RSQRT.D %s, %s", ft, fs);
+    return img_format("RSQRT.D %s, %s", ft, fs);
 }
 
 
@@ -12904,7 +12889,7 @@ std::string NMD::RSQRT_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("RSQRT.S %s, %s", ft, fs);
+    return img_format("RSQRT.S %s, %s", ft, fs);
 }
 
 
@@ -12925,7 +12910,7 @@ std::string NMD::SAVE_16_(uint64 instruction)
     uint64 count_value = extract_count_3_2_1_0(instruction);
 
     std::string u = IMMEDIATE(copy(u_value));
-    return img::format("SAVE %s%s", u,
+    return img_format("SAVE %s%s", u,
         save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
 }
 
@@ -12948,7 +12933,7 @@ std::string NMD::SAVE_32_(uint64 instruction)
     uint64 gp_value = extract_gp_2(instruction);
 
     std::string u = IMMEDIATE(copy(u_value));
-    return img::format("SAVE %s%s", u,
+    return img_format("SAVE %s%s", u,
                save_restore_list(rt_value, count_value, gp_value));
 }
 
@@ -12971,7 +12956,7 @@ std::string NMD::SAVEF(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string count = IMMEDIATE(copy(count_value));
 
-    return img::format("SAVEF %s, %s", u, count);
+    return img_format("SAVEF %s, %s", u, count);
 }
 
 
@@ -12995,7 +12980,7 @@ std::string NMD::SB_16_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
-    return img::format("SB %s, %s(%s)", rtz3, u, rs3);
+    return img_format("SB %s, %s(%s)", rtz3, u, rs3);
 }
 
 
@@ -13017,7 +13002,7 @@ std::string NMD::SB_GP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("SB %s, %s($%d)", rt, u, 28);
+    return img_format("SB %s, %s($%d)", rt, u, 28);
 }
 
 
@@ -13041,7 +13026,7 @@ std::string NMD::SB_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SB %s, %s(%s)", rt, s, rs);
+    return img_format("SB %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -13065,7 +13050,7 @@ std::string NMD::SB_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SB %s, %s(%s)", rt, u, rs);
+    return img_format("SB %s, %s(%s)", rt, u, rs);
 }
 
 
@@ -13089,7 +13074,7 @@ std::string NMD::SBE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SBE %s, %s(%s)", rt, s, rs);
+    return img_format("SBE %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -13113,7 +13098,7 @@ std::string NMD::SBX(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SBX %s, %s(%s)", rd, rs, rt);
+    return img_format("SBX %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -13137,7 +13122,7 @@ std::string NMD::SC(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SC %s, %s(%s)", rt, s, rs);
+    return img_format("SC %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -13161,7 +13146,7 @@ std::string NMD::SCD(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SCD %s, %s(%s)", rt, s, rs);
+    return img_format("SCD %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -13185,7 +13170,7 @@ std::string NMD::SCDP(uint64 instruction)
     std::string ru = GPR(copy(ru_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SCDP %s, %s, (%s)", rt, ru, rs);
+    return img_format("SCDP %s, %s, (%s)", rt, ru, rs);
 }
 
 
@@ -13209,7 +13194,7 @@ std::string NMD::SCE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SCE %s, %s(%s)", rt, s, rs);
+    return img_format("SCE %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -13233,7 +13218,7 @@ std::string NMD::SCWP(uint64 instruction)
     std::string ru = GPR(copy(ru_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SCWP %s, %s, (%s)", rt, ru, rs);
+    return img_format("SCWP %s, %s, (%s)", rt, ru, rs);
 }
 
 
@@ -13257,7 +13242,7 @@ std::string NMD::SCWPE(uint64 instruction)
     std::string ru = GPR(copy(ru_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SCWPE %s, %s, (%s)", rt, ru, rs);
+    return img_format("SCWPE %s, %s, (%s)", rt, ru, rs);
 }
 
 
@@ -13279,7 +13264,7 @@ std::string NMD::SD_GP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("SD %s, %s($%d)", rt, u, 28);
+    return img_format("SD %s, %s($%d)", rt, u, 28);
 }
 
 
@@ -13303,7 +13288,7 @@ std::string NMD::SD_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SD %s, %s(%s)", rt, s, rs);
+    return img_format("SD %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -13327,7 +13312,7 @@ std::string NMD::SD_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SD %s, %s(%s)", rt, u, rs);
+    return img_format("SD %s, %s(%s)", rt, u, rs);
 }
 
 
@@ -13347,7 +13332,7 @@ std::string NMD::SDBBP_16_(uint64 instruction)
 
     std::string code = IMMEDIATE(copy(code_value));
 
-    return img::format("SDBBP %s", code);
+    return img_format("SDBBP %s", code);
 }
 
 
@@ -13367,7 +13352,7 @@ std::string NMD::SDBBP_32_(uint64 instruction)
 
     std::string code = IMMEDIATE(copy(code_value));
 
-    return img::format("SDBBP %s", code);
+    return img_format("SDBBP %s", code);
 }
 
 
@@ -13389,7 +13374,7 @@ std::string NMD::SDC1_GP_(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("SDC1 %s, %s($%d)", ft, u, 28);
+    return img_format("SDC1 %s, %s($%d)", ft, u, 28);
 }
 
 
@@ -13413,7 +13398,7 @@ std::string NMD::SDC1_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SDC1 %s, %s(%s)", ft, s, rs);
+    return img_format("SDC1 %s, %s(%s)", ft, s, rs);
 }
 
 
@@ -13437,7 +13422,7 @@ std::string NMD::SDC1_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SDC1 %s, %s(%s)", ft, u, rs);
+    return img_format("SDC1 %s, %s(%s)", ft, u, rs);
 }
 
 
@@ -13461,7 +13446,7 @@ std::string NMD::SDC1X(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SDC1X %s, %s(%s)", ft, rs, rt);
+    return img_format("SDC1X %s, %s(%s)", ft, rs, rt);
 }
 
 
@@ -13485,7 +13470,7 @@ std::string NMD::SDC1XS(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SDC1XS %s, %s(%s)", ft, rs, rt);
+    return img_format("SDC1XS %s, %s(%s)", ft, rs, rt);
 }
 
 
@@ -13509,7 +13494,7 @@ std::string NMD::SDC2(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SDC2 %s, %s(%s)", cs, s, rs);
+    return img_format("SDC2 %s, %s(%s)", cs, s, rs);
 }
 
 
@@ -13535,7 +13520,7 @@ std::string NMD::SDM(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img::format("SDM %s, %s(%s), %s", rt, s, rs, count3);
+    return img_format("SDM %s, %s(%s), %s", rt, s, rs, count3);
 }
 
 
@@ -13557,7 +13542,7 @@ std::string NMD::SDPC_48_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 6);
 
-    return img::format("SDPC %s, %s", rt, s);
+    return img_format("SDPC %s, %s", rt, s);
 }
 
 
@@ -13581,7 +13566,7 @@ std::string NMD::SDXS(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SDXS %s, %s(%s)", rd, rs, rt);
+    return img_format("SDXS %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -13605,7 +13590,7 @@ std::string NMD::SDX(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SDX %s, %s(%s)", rd, rs, rt);
+    return img_format("SDX %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -13627,7 +13612,7 @@ std::string NMD::SEB(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SEB %s, %s", rt, rs);
+    return img_format("SEB %s, %s", rt, rs);
 }
 
 
@@ -13649,7 +13634,7 @@ std::string NMD::SEH(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SEH %s, %s", rt, rs);
+    return img_format("SEH %s, %s", rt, rs);
 }
 
 
@@ -13673,7 +13658,7 @@ std::string NMD::SEL_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("SEL.D %s, %s, %s", fd, fs, ft);
+    return img_format("SEL.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -13697,7 +13682,7 @@ std::string NMD::SEL_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("SEL.S %s, %s, %s", fd, fs, ft);
+    return img_format("SEL.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -13721,7 +13706,7 @@ std::string NMD::SELEQZ_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("SELEQZ.D %s, %s, %s", fd, fs, ft);
+    return img_format("SELEQZ.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -13745,7 +13730,7 @@ std::string NMD::SELEQZ_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("SELEQZ.S %s, %s, %s", fd, fs, ft);
+    return img_format("SELEQZ.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -13769,7 +13754,7 @@ std::string NMD::SELNEZ_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("SELNEZ.D %s, %s, %s", fd, fs, ft);
+    return img_format("SELNEZ.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -13793,7 +13778,7 @@ std::string NMD::SELNEZ_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("SELNEZ.S %s, %s, %s", fd, fs, ft);
+    return img_format("SELNEZ.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -13817,7 +13802,7 @@ std::string NMD::SEQI(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("SEQI %s, %s, %s", rt, rs, u);
+    return img_format("SEQI %s, %s, %s", rt, rs, u);
 }
 
 
@@ -13841,7 +13826,7 @@ std::string NMD::SH_16_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
-    return img::format("SH %s, %s(%s)", rtz3, u, rs3);
+    return img_format("SH %s, %s(%s)", rtz3, u, rs3);
 }
 
 
@@ -13863,7 +13848,7 @@ std::string NMD::SH_GP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("SH %s, %s($%d)", rt, u, 28);
+    return img_format("SH %s, %s($%d)", rt, u, 28);
 }
 
 
@@ -13887,7 +13872,7 @@ std::string NMD::SH_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SH %s, %s(%s)", rt, s, rs);
+    return img_format("SH %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -13911,7 +13896,7 @@ std::string NMD::SH_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SH %s, %s(%s)", rt, u, rs);
+    return img_format("SH %s, %s(%s)", rt, u, rs);
 }
 
 
@@ -13935,7 +13920,7 @@ std::string NMD::SHE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHE %s, %s(%s)", rt, s, rs);
+    return img_format("SHE %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -13957,7 +13942,7 @@ std::string NMD::SHILO(uint64 instruction)
     std::string shift = IMMEDIATE(copy(shift_value));
     std::string ac = AC(copy(ac_value));
 
-    return img::format("SHILO %s, %s", ac, shift);
+    return img_format("SHILO %s, %s", ac, shift);
 }
 
 
@@ -13979,7 +13964,7 @@ std::string NMD::SHILOV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string ac = AC(copy(ac_value));
 
-    return img::format("SHILOV %s, %s", ac, rs);
+    return img_format("SHILOV %s, %s", ac, rs);
 }
 
 
@@ -14003,7 +13988,7 @@ std::string NMD::SHLL_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("SHLL.PH %s, %s, %s", rt, rs, sa);
+    return img_format("SHLL.PH %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -14027,7 +14012,7 @@ std::string NMD::SHLL_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("SHLL.QB %s, %s, %s", rt, rs, sa);
+    return img_format("SHLL.QB %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -14052,7 +14037,7 @@ std::string NMD::SHLL_S_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
+    return img_format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -14076,7 +14061,7 @@ std::string NMD::SHLL_S_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("SHLL_S.W %s, %s, %s", rt, rs, sa);
+    return img_format("SHLL_S.W %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -14101,7 +14086,7 @@ std::string NMD::SHLLV_PH(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHLLV.PH %s, %s, %s", rd, rt, rs);
+    return img_format("SHLLV.PH %s, %s, %s", rd, rt, rs);
 }
 
 
@@ -14125,7 +14110,7 @@ std::string NMD::SHLLV_QB(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHLLV.QB %s, %s, %s", rd, rt, rs);
+    return img_format("SHLLV.QB %s, %s, %s", rd, rt, rs);
 }
 
 
@@ -14150,7 +14135,7 @@ std::string NMD::SHLLV_S_PH(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
+    return img_format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
 }
 
 
@@ -14174,7 +14159,7 @@ std::string NMD::SHLLV_S_W(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
+    return img_format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
 }
 
 
@@ -14198,7 +14183,7 @@ std::string NMD::SHRA_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("SHRA.PH %s, %s, %s", rt, rs, sa);
+    return img_format("SHRA.PH %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -14222,7 +14207,7 @@ std::string NMD::SHRA_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("SHRA.QB %s, %s, %s", rt, rs, sa);
+    return img_format("SHRA.QB %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -14246,7 +14231,7 @@ std::string NMD::SHRA_R_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
+    return img_format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -14270,7 +14255,7 @@ std::string NMD::SHRA_R_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
+    return img_format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -14294,7 +14279,7 @@ std::string NMD::SHRA_R_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("SHRA_R.W %s, %s, %s", rt, rs, sa);
+    return img_format("SHRA_R.W %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -14318,7 +14303,7 @@ std::string NMD::SHRAV_PH(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHRAV.PH %s, %s, %s", rd, rt, rs);
+    return img_format("SHRAV.PH %s, %s, %s", rd, rt, rs);
 }
 
 
@@ -14342,7 +14327,7 @@ std::string NMD::SHRAV_QB(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHRAV.QB %s, %s, %s", rd, rt, rs);
+    return img_format("SHRAV.QB %s, %s, %s", rd, rt, rs);
 }
 
 
@@ -14366,7 +14351,7 @@ std::string NMD::SHRAV_R_PH(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
+    return img_format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
 }
 
 
@@ -14390,7 +14375,7 @@ std::string NMD::SHRAV_R_QB(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
+    return img_format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
 }
 
 
@@ -14414,7 +14399,7 @@ std::string NMD::SHRAV_R_W(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
+    return img_format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
 }
 
 
@@ -14438,7 +14423,7 @@ std::string NMD::SHRL_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("SHRL.PH %s, %s, %s", rt, rs, sa);
+    return img_format("SHRL.PH %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -14462,7 +14447,7 @@ std::string NMD::SHRL_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string sa = IMMEDIATE(copy(sa_value));
 
-    return img::format("SHRL.QB %s, %s, %s", rt, rs, sa);
+    return img_format("SHRL.QB %s, %s, %s", rt, rs, sa);
 }
 
 
@@ -14487,7 +14472,7 @@ std::string NMD::SHRLV_PH(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHRLV.PH %s, %s, %s", rd, rt, rs);
+    return img_format("SHRLV.PH %s, %s, %s", rd, rt, rs);
 }
 
 
@@ -14511,7 +14496,7 @@ std::string NMD::SHRLV_QB(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SHRLV.QB %s, %s, %s", rd, rt, rs);
+    return img_format("SHRLV.QB %s, %s, %s", rd, rt, rs);
 }
 
 
@@ -14535,7 +14520,7 @@ std::string NMD::SHX(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SHX %s, %s(%s)", rd, rs, rt);
+    return img_format("SHX %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -14559,7 +14544,7 @@ std::string NMD::SHXS(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SHXS %s, %s(%s)", rd, rs, rt);
+    return img_format("SHXS %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -14579,7 +14564,7 @@ std::string NMD::SIGRIE(uint64 instruction)
 
     std::string code = IMMEDIATE(copy(code_value));
 
-    return img::format("SIGRIE %s", code);
+    return img_format("SIGRIE %s", code);
 }
 
 
@@ -14603,7 +14588,7 @@ std::string NMD::SLL_16_(uint64 instruction)
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
     std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
 
-    return img::format("SLL %s, %s, %s", rt3, rs3, shift3);
+    return img_format("SLL %s, %s, %s", rt3, rs3, shift3);
 }
 
 
@@ -14627,7 +14612,7 @@ std::string NMD::SLL_32_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("SLL %s, %s, %s", rt, rs, shift);
+    return img_format("SLL %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -14651,7 +14636,7 @@ std::string NMD::SLLV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SLLV %s, %s, %s", rd, rs, rt);
+    return img_format("SLLV %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -14675,7 +14660,7 @@ std::string NMD::SLT(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SLT %s, %s, %s", rd, rs, rt);
+    return img_format("SLT %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -14699,7 +14684,7 @@ std::string NMD::SLTI(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("SLTI %s, %s, %s", rt, rs, u);
+    return img_format("SLTI %s, %s, %s", rt, rs, u);
 }
 
 
@@ -14723,7 +14708,7 @@ std::string NMD::SLTIU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("SLTIU %s, %s, %s", rt, rs, u);
+    return img_format("SLTIU %s, %s, %s", rt, rs, u);
 }
 
 
@@ -14747,7 +14732,7 @@ std::string NMD::SLTU(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SLTU %s, %s, %s", rd, rs, rt);
+    return img_format("SLTU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -14771,7 +14756,7 @@ std::string NMD::SOV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SOV %s, %s, %s", rd, rs, rt);
+    return img_format("SOV %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -14791,7 +14776,7 @@ std::string NMD::SPECIAL2(uint64 instruction)
 
     std::string op = IMMEDIATE(copy(op_value));
 
-    return img::format("SPECIAL2 %s", op);
+    return img_format("SPECIAL2 %s", op);
 }
 
 
@@ -14813,7 +14798,7 @@ std::string NMD::SQRT_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("SQRT.D %s, %s", ft, fs);
+    return img_format("SQRT.D %s, %s", ft, fs);
 }
 
 
@@ -14835,7 +14820,7 @@ std::string NMD::SQRT_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("SQRT.S %s, %s", ft, fs);
+    return img_format("SQRT.S %s, %s", ft, fs);
 }
 
 
@@ -14859,7 +14844,7 @@ std::string NMD::SRA(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("SRA %s, %s, %s", rt, rs, shift);
+    return img_format("SRA %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -14883,7 +14868,7 @@ std::string NMD::SRAV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SRAV %s, %s, %s", rd, rs, rt);
+    return img_format("SRAV %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -14907,7 +14892,7 @@ std::string NMD::SRL_16_(uint64 instruction)
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
     std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
 
-    return img::format("SRL %s, %s, %s", rt3, rs3, shift3);
+    return img_format("SRL %s, %s, %s", rt3, rs3, shift3);
 }
 
 
@@ -14931,7 +14916,7 @@ std::string NMD::SRL_32_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string shift = IMMEDIATE(copy(shift_value));
 
-    return img::format("SRL %s, %s, %s", rt, rs, shift);
+    return img_format("SRL %s, %s, %s", rt, rs, shift);
 }
 
 
@@ -14955,7 +14940,7 @@ std::string NMD::SRLV(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SRLV %s, %s, %s", rd, rs, rt);
+    return img_format("SRLV %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -14979,7 +14964,7 @@ std::string NMD::SUB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUB %s, %s, %s", rd, rs, rt);
+    return img_format("SUB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15003,7 +14988,7 @@ std::string NMD::SUB_D(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("SUB.D %s, %s, %s", fd, fs, ft);
+    return img_format("SUB.D %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -15027,7 +15012,7 @@ std::string NMD::SUB_S(uint64 instruction)
     std::string fs = FPR(copy(fs_value));
     std::string ft = FPR(copy(ft_value));
 
-    return img::format("SUB.S %s, %s, %s", fd, fs, ft);
+    return img_format("SUB.S %s, %s, %s", fd, fs, ft);
 }
 
 
@@ -15051,7 +15036,7 @@ std::string NMD::SUBQ_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBQ.PH %s, %s, %s", rd, rs, rt);
+    return img_format("SUBQ.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15076,7 +15061,7 @@ std::string NMD::SUBQ_S_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
+    return img_format("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15101,7 +15086,7 @@ std::string NMD::SUBQ_S_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
+    return img_format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15126,7 +15111,7 @@ std::string NMD::SUBQH_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBQH.PH %s, %s, %s", rd, rs, rt);
+    return img_format("SUBQH.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15151,7 +15136,7 @@ std::string NMD::SUBQH_R_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
+    return img_format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15176,7 +15161,7 @@ std::string NMD::SUBQH_R_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
+    return img_format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15201,7 +15186,7 @@ std::string NMD::SUBQH_W(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBQH.W %s, %s, %s", rd, rs, rt);
+    return img_format("SUBQH.W %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15225,7 +15210,7 @@ std::string NMD::SUBU_16_(uint64 instruction)
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
 
-    return img::format("SUBU %s, %s, %s", rd3, rs3, rt3);
+    return img_format("SUBU %s, %s, %s", rd3, rs3, rt3);
 }
 
 
@@ -15249,7 +15234,7 @@ std::string NMD::SUBU_32_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBU %s, %s, %s", rd, rs, rt);
+    return img_format("SUBU %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15273,7 +15258,7 @@ std::string NMD::SUBU_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBU.PH %s, %s, %s", rd, rs, rt);
+    return img_format("SUBU.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15297,7 +15282,7 @@ std::string NMD::SUBU_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBU.QB %s, %s, %s", rd, rs, rt);
+    return img_format("SUBU.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15322,7 +15307,7 @@ std::string NMD::SUBU_S_PH(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
+    return img_format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15347,7 +15332,7 @@ std::string NMD::SUBU_S_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
+    return img_format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15372,7 +15357,7 @@ std::string NMD::SUBUH_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBUH.QB %s, %s, %s", rd, rs, rt);
+    return img_format("SUBUH.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15397,7 +15382,7 @@ std::string NMD::SUBUH_R_QB(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
+    return img_format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -15421,7 +15406,7 @@ std::string NMD::SW_16_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
-    return img::format("SW %s, %s(%s)", rtz3, u, rs3);
+    return img_format("SW %s, %s(%s)", rtz3, u, rs3);
 }
 
 
@@ -15445,7 +15430,7 @@ std::string NMD::SW_4X4_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
 
-    return img::format("SW %s, %s(%s)", rtz4, u, rs4);
+    return img_format("SW %s, %s(%s)", rtz4, u, rs4);
 }
 
 
@@ -15467,7 +15452,7 @@ std::string NMD::SW_GP16_(uint64 instruction)
     std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("SW %s, %s($%d)", rtz3, u, 28);
+    return img_format("SW %s, %s($%d)", rtz3, u, 28);
 }
 
 
@@ -15489,7 +15474,7 @@ std::string NMD::SW_GP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("SW %s, %s($%d)", rt, u, 28);
+    return img_format("SW %s, %s($%d)", rt, u, 28);
 }
 
 
@@ -15513,7 +15498,7 @@ std::string NMD::SW_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SW %s, %s(%s)", rt, s, rs);
+    return img_format("SW %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -15535,7 +15520,7 @@ std::string NMD::SW_SP_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("SW %s, %s($%d)", rt, u, 29);
+    return img_format("SW %s, %s($%d)", rt, u, 29);
 }
 
 
@@ -15559,7 +15544,7 @@ std::string NMD::SW_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SW %s, %s(%s)", rt, u, rs);
+    return img_format("SW %s, %s(%s)", rt, u, rs);
 }
 
 
@@ -15581,7 +15566,7 @@ std::string NMD::SWC1_GP_(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("SWC1 %s, %s($%d)", ft, u, 28);
+    return img_format("SWC1 %s, %s($%d)", ft, u, 28);
 }
 
 
@@ -15605,7 +15590,7 @@ std::string NMD::SWC1_S9_(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SWC1 %s, %s(%s)", ft, s, rs);
+    return img_format("SWC1 %s, %s(%s)", ft, s, rs);
 }
 
 
@@ -15629,7 +15614,7 @@ std::string NMD::SWC1_U12_(uint64 instruction)
     std::string u = IMMEDIATE(copy(u_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SWC1 %s, %s(%s)", ft, u, rs);
+    return img_format("SWC1 %s, %s(%s)", ft, u, rs);
 }
 
 
@@ -15653,7 +15638,7 @@ std::string NMD::SWC1X(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SWC1X %s, %s(%s)", ft, rs, rt);
+    return img_format("SWC1X %s, %s(%s)", ft, rs, rt);
 }
 
 
@@ -15677,7 +15662,7 @@ std::string NMD::SWC1XS(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SWC1XS %s, %s(%s)", ft, rs, rt);
+    return img_format("SWC1XS %s, %s(%s)", ft, rs, rt);
 }
 
 
@@ -15701,7 +15686,7 @@ std::string NMD::SWC2(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SWC2 %s, %s(%s)", cs, s, rs);
+    return img_format("SWC2 %s, %s(%s)", cs, s, rs);
 }
 
 
@@ -15725,7 +15710,7 @@ std::string NMD::SWE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SWE %s, %s(%s)", rt, s, rs);
+    return img_format("SWE %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -15751,7 +15736,7 @@ std::string NMD::SWM(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img::format("SWM %s, %s(%s), %s", rt, s, rs, count3);
+    return img_format("SWM %s, %s(%s), %s", rt, s, rs, count3);
 }
 
 
@@ -15773,7 +15758,7 @@ std::string NMD::SWPC_48_(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string s = ADDRESS(encode_s_from_address(s_value), 6);
 
-    return img::format("SWPC %s, %s", rt, s);
+    return img_format("SWPC %s, %s", rt, s);
 }
 
 
@@ -15797,7 +15782,7 @@ std::string NMD::SWX(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SWX %s, %s(%s)", rd, rs, rt);
+    return img_format("SWX %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -15821,7 +15806,7 @@ std::string NMD::SWXS(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("SWXS %s, %s(%s)", rd, rs, rt);
+    return img_format("SWXS %s, %s(%s)", rd, rs, rt);
 }
 
 
@@ -15841,7 +15826,7 @@ std::string NMD::SYNC(uint64 instruction)
 
     std::string stype = IMMEDIATE(copy(stype_value));
 
-    return img::format("SYNC %s", stype);
+    return img_format("SYNC %s", stype);
 }
 
 
@@ -15863,7 +15848,7 @@ std::string NMD::SYNCI(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SYNCI %s(%s)", s, rs);
+    return img_format("SYNCI %s(%s)", s, rs);
 }
 
 
@@ -15885,7 +15870,7 @@ std::string NMD::SYNCIE(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("SYNCIE %s(%s)", s, rs);
+    return img_format("SYNCIE %s(%s)", s, rs);
 }
 
 
@@ -15905,7 +15890,7 @@ std::string NMD::SYSCALL_16_(uint64 instruction)
 
     std::string code = IMMEDIATE(copy(code_value));
 
-    return img::format("SYSCALL %s", code);
+    return img_format("SYSCALL %s", code);
 }
 
 
@@ -15923,7 +15908,7 @@ std::string NMD::SYSCALL_32_(uint64 instruction)
 
     std::string code = IMMEDIATE(copy(code_value));
 
-    return img::format("SYSCALL %s", code);
+    return img_format("SYSCALL %s", code);
 }
 
 
@@ -15945,7 +15930,7 @@ std::string NMD::TEQ(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("TEQ %s, %s", rs, rt);
+    return img_format("TEQ %s, %s", rs, rt);
 }
 
 
@@ -16183,7 +16168,7 @@ std::string NMD::TNE(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("TNE %s, %s", rs, rt);
+    return img_format("TNE %s, %s", rs, rt);
 }
 
 
@@ -16205,7 +16190,7 @@ std::string NMD::TRUNC_L_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("TRUNC.L.D %s, %s", ft, fs);
+    return img_format("TRUNC.L.D %s, %s", ft, fs);
 }
 
 
@@ -16227,7 +16212,7 @@ std::string NMD::TRUNC_L_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("TRUNC.L.S %s, %s", ft, fs);
+    return img_format("TRUNC.L.S %s, %s", ft, fs);
 }
 
 
@@ -16249,7 +16234,7 @@ std::string NMD::TRUNC_W_D(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("TRUNC.W.D %s, %s", ft, fs);
+    return img_format("TRUNC.W.D %s, %s", ft, fs);
 }
 
 
@@ -16271,7 +16256,7 @@ std::string NMD::TRUNC_W_S(uint64 instruction)
     std::string ft = FPR(copy(ft_value));
     std::string fs = FPR(copy(fs_value));
 
-    return img::format("TRUNC.W.S %s, %s", ft, fs);
+    return img_format("TRUNC.W.S %s, %s", ft, fs);
 }
 
 
@@ -16297,7 +16282,7 @@ std::string NMD::UALDM(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img::format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
+    return img_format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
 }
 
 
@@ -16321,7 +16306,7 @@ std::string NMD::UALH(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("UALH %s, %s(%s)", rt, s, rs);
+    return img_format("UALH %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -16347,7 +16332,7 @@ std::string NMD::UALWM(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img::format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
+    return img_format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
 }
 
 
@@ -16373,7 +16358,7 @@ std::string NMD::UASDM(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img::format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
+    return img_format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
 }
 
 
@@ -16397,7 +16382,7 @@ std::string NMD::UASH(uint64 instruction)
     std::string s = IMMEDIATE(copy(s_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("UASH %s, %s(%s)", rt, s, rs);
+    return img_format("UASH %s, %s(%s)", rt, s, rs);
 }
 
 
@@ -16423,7 +16408,7 @@ std::string NMD::UASWM(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img::format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
+    return img_format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
 }
 
 
@@ -16443,7 +16428,7 @@ std::string NMD::UDI(uint64 instruction)
 
     std::string op = IMMEDIATE(copy(op_value));
 
-    return img::format("UDI %s", op);
+    return img_format("UDI %s", op);
 }
 
 
@@ -16461,7 +16446,7 @@ std::string NMD::WAIT(uint64 instruction)
 
     std::string code = IMMEDIATE(copy(code_value));
 
-    return img::format("WAIT %s", code);
+    return img_format("WAIT %s", code);
 }
 
 
@@ -16483,7 +16468,7 @@ std::string NMD::WRDSP(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string mask = IMMEDIATE(copy(mask_value));
 
-    return img::format("WRDSP %s, %s", rt, mask);
+    return img_format("WRDSP %s, %s", rt, mask);
 }
 
 
@@ -16505,7 +16490,7 @@ std::string NMD::WRPGPR(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("WRPGPR %s, %s", rt, rs);
+    return img_format("WRPGPR %s, %s", rt, rs);
 }
 
 
@@ -16527,7 +16512,7 @@ std::string NMD::XOR_16_(uint64 instruction)
     std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
 
-    return img::format("XOR %s, %s", rs3, rt3);
+    return img_format("XOR %s, %s", rs3, rt3);
 }
 
 
@@ -16551,7 +16536,7 @@ std::string NMD::XOR_32_(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
 
-    return img::format("XOR %s, %s, %s", rd, rs, rt);
+    return img_format("XOR %s, %s, %s", rd, rs, rt);
 }
 
 
@@ -16575,7 +16560,7 @@ std::string NMD::XORI(uint64 instruction)
     std::string rs = GPR(copy(rs_value));
     std::string u = IMMEDIATE(copy(u_value));
 
-    return img::format("XORI %s, %s, %s", rt, rs, u);
+    return img_format("XORI %s, %s, %s", rt, rs, u);
 }
 
 
@@ -16596,7 +16581,7 @@ std::string NMD::YIELD(uint64 instruction)
     std::string rt = GPR(copy(rt_value));
     std::string rs = GPR(copy(rs_value));
 
-    return img::format("YIELD %s, %s", rt, rs);
+    return img_format("YIELD %s, %s", rt, rs);
 }
 
 
diff --git a/disas/nanomips.h b/disas/nanomips.h
index a0a2225301..9fe0cc67da 100644
--- a/disas/nanomips.h
+++ b/disas/nanomips.h
@@ -29,11 +29,7 @@ typedef int64_t int64;
 typedef uint64_t uint64;
 typedef uint32_t uint32;
 typedef uint16_t uint16;
-
-namespace img
-{
-    typedef uint64_t address;
-}
+typedef uint64_t img_address;
 
 
 class NMD
@@ -70,7 +66,7 @@ public:
     };
 
 
-    NMD(img::address pc, TABLE_ATTRIBUTE_TYPE requested_instruction_categories)
+    NMD(img_address pc, TABLE_ATTRIBUTE_TYPE requested_instruction_categories)
         : m_pc(pc)
         , m_requested_instruction_categories(requested_instruction_categories)
     {
@@ -81,7 +77,7 @@ public:
 
 private:
 
-    img::address           m_pc;
+    img_address           m_pc;
     TABLE_ATTRIBUTE_TYPE   m_requested_instruction_categories;
 
     typedef std::string(NMD:: *disassembly_function)(uint64 instruction);
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 01/20] disas/nanomips: Remove namespace img
  2022-09-05  9:55 ` [PATCH v2 01/20] disas/nanomips: Remove namespace img Milica Lazarevic
@ 2022-09-05 11:00   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:00 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> Since there's no namespace feature in C, namespace img has been replaced
> with adding the prefix "img" to the namespace members.
> 
> Prefix "img" has been added to the function names of functions that used
> to be wrapped in namespace img. Those are img::format() functions.
> I.e. replaced img::format with the img_format.
> 
> Typedef address that used to belong to namespace img now is called
> img_address.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> Reviewed-by: Thomas Huth<thuth@redhat.com>
> ---
>   disas/nanomips.cpp | 1433 ++++++++++++++++++++++----------------------
>   disas/nanomips.h   |   10 +-
>   2 files changed, 712 insertions(+), 731 deletions(-)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 02/20] disas/nanomips: Extract enums out of the NMD class
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
  2022-09-05  9:55 ` [PATCH v2 01/20] disas/nanomips: Remove namespace img Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:00   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 03/20] disas/nanomips: Delete NMD class fields Milica Lazarevic
                   ` (17 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

Definitions of enums TABLE_ENTRY_TYPE and TABLE_ATTRIBUTE_TYPE are moved
out of the NMD class. The main goal is to remove NMD class completely.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
---
 disas/nanomips.cpp |  8 +++----
 disas/nanomips.h   | 59 +++++++++++++++++++++++-----------------------
 2 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index 84529685bf..bdc640b38b 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -50,8 +50,8 @@ int nanomips_dis(char *buf,
     std::string disasm;
     uint16 bits[3] = {one, two, three};
 
-    NMD::TABLE_ENTRY_TYPE type;
-    NMD d(address, NMD::ALL_ATTRIBUTES);
+    TABLE_ENTRY_TYPE type;
+    NMD d(address, ALL_ATTRIBUTES);
     int size = d.Disassemble(bits, disasm, type);
 
     strcpy(buf, disasm.c_str());
@@ -772,7 +772,7 @@ uint64 NMD::extract_op_code_value(const uint16 * data, int size)
 
 
 int NMD::Disassemble(const uint16 * data, std::string & dis,
-                     NMD::TABLE_ENTRY_TYPE & type)
+                     TABLE_ENTRY_TYPE & type)
 {
     return Disassemble(data, dis, type, MAJOR, 2);
 }
@@ -790,7 +790,7 @@ int NMD::Disassemble(const uint16 * data, std::string & dis,
  *      disassembly string  - on error will constain error string
  */
 int NMD::Disassemble(const uint16 * data, std::string & dis,
-                     NMD::TABLE_ENTRY_TYPE & type, const Pool *table,
+                     TABLE_ENTRY_TYPE & type, const Pool *table,
                      int table_size)
 {
     try
diff --git a/disas/nanomips.h b/disas/nanomips.h
index 9fe0cc67da..f65a0957b8 100644
--- a/disas/nanomips.h
+++ b/disas/nanomips.h
@@ -31,41 +31,40 @@ typedef uint32_t uint32;
 typedef uint16_t uint16;
 typedef uint64_t img_address;
 
+enum TABLE_ENTRY_TYPE {
+    instruction,
+    call_instruction,
+    branch_instruction,
+    return_instruction,
+    reserved_block,
+    pool,
+};
+
+enum TABLE_ATTRIBUTE_TYPE {
+    MIPS64_    = 0x00000001,
+    XNP_       = 0x00000002,
+    XMMS_      = 0x00000004,
+    EVA_       = 0x00000008,
+    DSP_       = 0x00000010,
+    MT_        = 0x00000020,
+    EJTAG_     = 0x00000040,
+    TLBINV_    = 0x00000080,
+    CP0_       = 0x00000100,
+    CP1_       = 0x00000200,
+    CP2_       = 0x00000400,
+    UDI_       = 0x00000800,
+    MCU_       = 0x00001000,
+    VZ_        = 0x00002000,
+    TLB_       = 0x00004000,
+    MVH_       = 0x00008000,
+    ALL_ATTRIBUTES = 0xffffffffull,
+};
+
 
 class NMD
 {
 public:
 
-    enum TABLE_ENTRY_TYPE {
-        instruction,
-        call_instruction,
-        branch_instruction,
-        return_instruction,
-        reserved_block,
-        pool,
-    };
-
-    enum TABLE_ATTRIBUTE_TYPE {
-        MIPS64_    = 0x00000001,
-        XNP_       = 0x00000002,
-        XMMS_      = 0x00000004,
-        EVA_       = 0x00000008,
-        DSP_       = 0x00000010,
-        MT_        = 0x00000020,
-        EJTAG_     = 0x00000040,
-        TLBINV_    = 0x00000080,
-        CP0_       = 0x00000100,
-        CP1_       = 0x00000200,
-        CP2_       = 0x00000400,
-        UDI_       = 0x00000800,
-        MCU_       = 0x00001000,
-        VZ_        = 0x00002000,
-        TLB_       = 0x00004000,
-        MVH_       = 0x00008000,
-        ALL_ATTRIBUTES = 0xffffffffull,
-    };
-
-
     NMD(img_address pc, TABLE_ATTRIBUTE_TYPE requested_instruction_categories)
         : m_pc(pc)
         , m_requested_instruction_categories(requested_instruction_categories)
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 02/20] disas/nanomips: Extract enums out of the NMD class
  2022-09-05  9:55 ` [PATCH v2 02/20] disas/nanomips: Extract enums out of the NMD class Milica Lazarevic
@ 2022-09-05 11:00   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:00 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> Definitions of enums TABLE_ENTRY_TYPE and TABLE_ATTRIBUTE_TYPE are moved
> out of the NMD class. The main goal is to remove NMD class completely.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> Reviewed-by: Thomas Huth<thuth@redhat.com>
> ---
>   disas/nanomips.cpp |  8 +++----
>   disas/nanomips.h   | 59 +++++++++++++++++++++++-----------------------
>   2 files changed, 33 insertions(+), 34 deletions(-)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 03/20] disas/nanomips: Delete NMD class fields
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
  2022-09-05  9:55 ` [PATCH v2 01/20] disas/nanomips: Remove namespace img Milica Lazarevic
  2022-09-05  9:55 ` [PATCH v2 02/20] disas/nanomips: Extract enums out of the NMD class Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:04   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 04/20] disas/nanomips: Remove helper methods from class Milica Lazarevic
                   ` (16 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

Two class fields have been deleted.

Since the m_requested_instruction_categories field always has the same
value, which is ALL_ATTRIBUTES, the only use of that field has been
replaced with the concrete ALL_ATTRIBUTES value.

The second class field m_pc is added as a parameter where needed.
Therefore, prototypes of the following functions have been changed:
- public NMD::Disassemble method
- private NMD::Disassemble method
- NMD::ADDRESS method
- all of the disassembly_function methods

Accordingly, the disassembly_function typedef has been changed.

There is no more need for a constructor, so the NMD constructor has been
deleted. The main goal is to remove NMD class completely.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
---
 disas/nanomips.cpp | 1361 ++++++++++++++++++++++----------------------
 disas/nanomips.h   | 1291 +++++++++++++++++++++--------------------
 2 files changed, 1322 insertions(+), 1330 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index bdc640b38b..49cdf23dbc 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -51,8 +51,8 @@ int nanomips_dis(char *buf,
     uint16 bits[3] = {one, two, three};
 
     TABLE_ENTRY_TYPE type;
-    NMD d(address, ALL_ATTRIBUTES);
-    int size = d.Disassemble(bits, disasm, type);
+    NMD d;
+    int size = d.Disassemble(bits, disasm, type, address);
 
     strcpy(buf, disasm.c_str());
     return size;
@@ -747,7 +747,7 @@ std::string NMD::CPR(uint64 reg)
 }
 
 
-std::string NMD::ADDRESS(uint64 value, int instruction_size)
+std::string NMD::ADDRESS(uint64 value, int instruction_size, img_address m_pc)
 {
     /* token for string replace */
     img_address address = m_pc + value + instruction_size;
@@ -772,9 +772,9 @@ uint64 NMD::extract_op_code_value(const uint16 * data, int size)
 
 
 int NMD::Disassemble(const uint16 * data, std::string & dis,
-                     TABLE_ENTRY_TYPE & type)
+                     TABLE_ENTRY_TYPE & type, img_address m_pc)
 {
-    return Disassemble(data, dis, type, MAJOR, 2);
+    return Disassemble(data, dis, type, MAJOR, 2, m_pc);
 }
 
 
@@ -791,7 +791,7 @@ int NMD::Disassemble(const uint16 * data, std::string & dis,
  */
 int NMD::Disassemble(const uint16 * data, std::string & dis,
                      TABLE_ENTRY_TYPE & type, const Pool *table,
-                     int table_size)
+                     int table_size, img_address m_pc)
 {
     try
     {
@@ -807,14 +807,13 @@ int NMD::Disassemble(const uint16 * data, std::string & dis,
                         if (table[i].type == pool) {
                             return Disassemble(data, dis, type,
                                                table[i].next_table,
-                                               table[i].next_table_size);
+                                               table[i].next_table_size, m_pc);
                         } else if ((table[i].type == instruction) ||
                                    (table[i].type == call_instruction) ||
                                    (table[i].type == branch_instruction) ||
                                    (table[i].type == return_instruction)) {
                             if ((table[i].attributes != 0) &&
-                                (m_requested_instruction_categories &
-                                 table[i].attributes) == 0) {
+                                (ALL_ATTRIBUTES & table[i].attributes) == 0) {
                                 /*
                                  * failed due to instruction having
                                  * an ASE attribute and the requested version
@@ -829,7 +828,7 @@ int NMD::Disassemble(const uint16 * data, std::string & dis,
                                 return -6;
                             }
                             type = table[i].type;
-                            dis = (this->*dis_fn)(op_code);
+                            dis = (this->*dis_fn)(op_code, m_pc);
                             return table[i].instructions_size;
                         } else {
                             dis = "reserved instruction";
@@ -1784,7 +1783,7 @@ bool NMD::SLTU_cond(uint64 instruction)
  *               fs -----
  *                    fd -----
  */
-std::string NMD::ABS_D(uint64 instruction)
+std::string NMD::ABS_D(uint64 instruction, img_address m_pc)
 {
     uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -1806,7 +1805,7 @@ std::string NMD::ABS_D(uint64 instruction)
  *               fd -----
  *                    fs -----
  */
-std::string NMD::ABS_S(uint64 instruction)
+std::string NMD::ABS_S(uint64 instruction, img_address m_pc)
 {
     uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -1828,7 +1827,7 @@ std::string NMD::ABS_S(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ABSQ_S_PH(uint64 instruction)
+std::string NMD::ABSQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1850,7 +1849,7 @@ std::string NMD::ABSQ_S_PH(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ABSQ_S_QB(uint64 instruction)
+std::string NMD::ABSQ_S_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1872,7 +1871,7 @@ std::string NMD::ABSQ_S_QB(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ABSQ_S_W(uint64 instruction)
+std::string NMD::ABSQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1893,7 +1892,7 @@ std::string NMD::ABSQ_S_W(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ACLR(uint64 instruction)
+std::string NMD::ACLR(uint64 instruction, img_address m_pc)
 {
     uint64 bit_value = extract_bit_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1916,7 +1915,7 @@ std::string NMD::ACLR(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADD(uint64 instruction)
+std::string NMD::ADD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1941,7 +1940,7 @@ std::string NMD::ADD(uint64 instruction)
  *               fs -----
  *                    fd -----
  */
-std::string NMD::ADD_D(uint64 instruction)
+std::string NMD::ADD_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -1966,7 +1965,7 @@ std::string NMD::ADD_D(uint64 instruction)
  *               fs -----
  *                    fd -----
  */
-std::string NMD::ADD_S(uint64 instruction)
+std::string NMD::ADD_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -1989,7 +1988,7 @@ std::string NMD::ADD_S(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_32_(uint64 instruction)
+std::string NMD::ADDIU_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2012,7 +2011,7 @@ std::string NMD::ADDIU_32_(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_48_(uint64 instruction)
+std::string NMD::ADDIU_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -2033,7 +2032,7 @@ std::string NMD::ADDIU_48_(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_GP48_(uint64 instruction)
+std::string NMD::ADDIU_GP48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -2054,7 +2053,7 @@ std::string NMD::ADDIU_GP48_(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_GP_B_(uint64 instruction)
+std::string NMD::ADDIU_GP_B_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
@@ -2075,7 +2074,7 @@ std::string NMD::ADDIU_GP_B_(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_GP_W_(uint64 instruction)
+std::string NMD::ADDIU_GP_W_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
@@ -2096,7 +2095,7 @@ std::string NMD::ADDIU_GP_W_(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_NEG_(uint64 instruction)
+std::string NMD::ADDIU_NEG_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2119,7 +2118,7 @@ std::string NMD::ADDIU_NEG_(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_R1_SP_(uint64 instruction)
+std::string NMD::ADDIU_R1_SP_(uint64 instruction, img_address m_pc)
 {
     uint64 u_value = extract_u_5_4_3_2_1_0__s2(instruction);
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
@@ -2140,7 +2139,7 @@ std::string NMD::ADDIU_R1_SP_(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_R2_(uint64 instruction)
+std::string NMD::ADDIU_R2_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -2162,7 +2161,7 @@ std::string NMD::ADDIU_R2_(uint64 instruction)
  *     rt -----
  *           s - ---
  */
-std::string NMD::ADDIU_RS5_(uint64 instruction)
+std::string NMD::ADDIU_RS5_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     int64 s_value = extract_s__se3_4_2_1_0(instruction);
@@ -2184,13 +2183,13 @@ std::string NMD::ADDIU_RS5_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDIUPC_32_(uint64 instruction)
+std::string NMD::ADDIUPC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
 
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("ADDIUPC %s, %s", rt, s);
 }
@@ -2206,13 +2205,13 @@ std::string NMD::ADDIUPC_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDIUPC_48_(uint64 instruction)
+std::string NMD::ADDIUPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 6);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("ADDIUPC %s, %s", rt, s);
 }
@@ -2228,7 +2227,7 @@ std::string NMD::ADDIUPC_48_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQ_PH(uint64 instruction)
+std::string NMD::ADDQ_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2253,7 +2252,7 @@ std::string NMD::ADDQ_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQ_S_PH(uint64 instruction)
+std::string NMD::ADDQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2277,7 +2276,7 @@ std::string NMD::ADDQ_S_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQ_S_W(uint64 instruction)
+std::string NMD::ADDQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2302,7 +2301,7 @@ std::string NMD::ADDQ_S_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQH_PH(uint64 instruction)
+std::string NMD::ADDQH_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2327,7 +2326,7 @@ std::string NMD::ADDQH_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQH_R_PH(uint64 instruction)
+std::string NMD::ADDQH_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2352,7 +2351,7 @@ std::string NMD::ADDQH_R_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQH_R_W(uint64 instruction)
+std::string NMD::ADDQH_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2377,7 +2376,7 @@ std::string NMD::ADDQH_R_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQH_W(uint64 instruction)
+std::string NMD::ADDQH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2401,7 +2400,7 @@ std::string NMD::ADDQH_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDSC(uint64 instruction)
+std::string NMD::ADDSC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2424,7 +2423,7 @@ std::string NMD::ADDSC(uint64 instruction)
  *       rs3 ---
  *          rd3 ---
  */
-std::string NMD::ADDU_16_(uint64 instruction)
+std::string NMD::ADDU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -2448,7 +2447,7 @@ std::string NMD::ADDU_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_32_(uint64 instruction)
+std::string NMD::ADDU_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2472,7 +2471,7 @@ std::string NMD::ADDU_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_4X4_(uint64 instruction)
+std::string NMD::ADDU_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
@@ -2494,7 +2493,7 @@ std::string NMD::ADDU_4X4_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_PH(uint64 instruction)
+std::string NMD::ADDU_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2518,7 +2517,7 @@ std::string NMD::ADDU_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_QB(uint64 instruction)
+std::string NMD::ADDU_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2543,7 +2542,7 @@ std::string NMD::ADDU_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_S_PH(uint64 instruction)
+std::string NMD::ADDU_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2567,7 +2566,7 @@ std::string NMD::ADDU_S_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_S_QB(uint64 instruction)
+std::string NMD::ADDU_S_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2592,7 +2591,7 @@ std::string NMD::ADDU_S_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDUH_QB(uint64 instruction)
+std::string NMD::ADDUH_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2617,7 +2616,7 @@ std::string NMD::ADDUH_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDUH_R_QB(uint64 instruction)
+std::string NMD::ADDUH_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2640,7 +2639,7 @@ std::string NMD::ADDUH_R_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDWC(uint64 instruction)
+std::string NMD::ADDWC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2664,13 +2663,13 @@ std::string NMD::ADDWC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ALUIPC(uint64 instruction)
+std::string NMD::ALUIPC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
 
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
 }
@@ -2685,7 +2684,7 @@ std::string NMD::ALUIPC(uint64 instruction)
  *       rs3 ---
  *           eu ----
  */
-std::string NMD::AND_16_(uint64 instruction)
+std::string NMD::AND_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -2707,7 +2706,7 @@ std::string NMD::AND_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::AND_32_(uint64 instruction)
+std::string NMD::AND_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2730,7 +2729,7 @@ std::string NMD::AND_32_(uint64 instruction)
  *       rs3 ---
  *           eu ----
  */
-std::string NMD::ANDI_16_(uint64 instruction)
+std::string NMD::ANDI_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -2754,7 +2753,7 @@ std::string NMD::ANDI_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ANDI_32_(uint64 instruction)
+std::string NMD::ANDI_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2778,7 +2777,7 @@ std::string NMD::ANDI_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::APPEND(uint64 instruction)
+std::string NMD::APPEND(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2802,7 +2801,7 @@ std::string NMD::APPEND(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ASET(uint64 instruction)
+std::string NMD::ASET(uint64 instruction, img_address m_pc)
 {
     uint64 bit_value = extract_bit_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2826,11 +2825,11 @@ std::string NMD::ASET(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BALC_16_(uint64 instruction)
+std::string NMD::BALC_16_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
 
-    std::string s = ADDRESS(encode_s_from_address(s_value), 2);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BALC %s", s);
 }
@@ -2846,11 +2845,11 @@ std::string NMD::BALC_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BALC_32_(uint64 instruction)
+std::string NMD::BALC_32_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
 
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BALC %s", s);
 }
@@ -2866,7 +2865,7 @@ std::string NMD::BALC_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BALRSC(uint64 instruction)
+std::string NMD::BALRSC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2888,7 +2887,7 @@ std::string NMD::BALRSC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BBEQZC(uint64 instruction)
+std::string NMD::BBEQZC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
@@ -2896,7 +2895,7 @@ std::string NMD::BBEQZC(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
     std::string bit = IMMEDIATE(copy(bit_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BBEQZC %s, %s, %s", rt, bit, s);
 }
@@ -2912,7 +2911,7 @@ std::string NMD::BBEQZC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BBNEZC(uint64 instruction)
+std::string NMD::BBNEZC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
@@ -2920,7 +2919,7 @@ std::string NMD::BBNEZC(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
     std::string bit = IMMEDIATE(copy(bit_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BBNEZC %s, %s, %s", rt, bit, s);
 }
@@ -2936,11 +2935,11 @@ std::string NMD::BBNEZC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC_16_(uint64 instruction)
+std::string NMD::BC_16_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
 
-    std::string s = ADDRESS(encode_s_from_address(s_value), 2);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BC %s", s);
 }
@@ -2956,11 +2955,11 @@ std::string NMD::BC_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC_32_(uint64 instruction)
+std::string NMD::BC_32_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
 
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC %s", s);
 }
@@ -2976,13 +2975,13 @@ std::string NMD::BC_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC1EQZC(uint64 instruction)
+std::string NMD::BC1EQZC(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
     std::string ft = FPR(copy(ft_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC1EQZC %s, %s", ft, s);
 }
@@ -2998,13 +2997,13 @@ std::string NMD::BC1EQZC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC1NEZC(uint64 instruction)
+std::string NMD::BC1NEZC(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
     std::string ft = FPR(copy(ft_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC1NEZC %s, %s", ft, s);
 }
@@ -3020,13 +3019,13 @@ std::string NMD::BC1NEZC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC2EQZC(uint64 instruction)
+std::string NMD::BC2EQZC(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
     std::string ct = CPR(copy(ct_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC2EQZC %s, %s", ct, s);
 }
@@ -3042,13 +3041,13 @@ std::string NMD::BC2EQZC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC2NEZC(uint64 instruction)
+std::string NMD::BC2NEZC(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
     std::string ct = CPR(copy(ct_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC2NEZC %s, %s", ct, s);
 }
@@ -3064,7 +3063,7 @@ std::string NMD::BC2NEZC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BEQC_16_(uint64 instruction)
+std::string NMD::BEQC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -3072,7 +3071,7 @@ std::string NMD::BEQC_16_(uint64 instruction)
 
     std::string rs3 = GPR(encode_rs3_and_check_rs3_lt_rt3(rs3_value));
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string u = ADDRESS(encode_u_from_address(u_value), 2);
+    std::string u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
 
     return img_format("BEQC %s, %s, %s", rs3, rt3, u);
 }
@@ -3088,7 +3087,7 @@ std::string NMD::BEQC_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BEQC_32_(uint64 instruction)
+std::string NMD::BEQC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3096,7 +3095,7 @@ std::string NMD::BEQC_32_(uint64 instruction)
 
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BEQC %s, %s, %s", rs, rt, s);
 }
@@ -3112,7 +3111,7 @@ std::string NMD::BEQC_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BEQIC(uint64 instruction)
+std::string NMD::BEQIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3120,7 +3119,7 @@ std::string NMD::BEQIC(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BEQIC %s, %s, %s", rt, u, s);
 }
@@ -3136,13 +3135,13 @@ std::string NMD::BEQIC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BEQZC_16_(uint64 instruction)
+std::string NMD::BEQZC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
 
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 2);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BEQZC %s, %s", rt3, s);
 }
@@ -3158,7 +3157,7 @@ std::string NMD::BEQZC_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BGEC(uint64 instruction)
+std::string NMD::BGEC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3166,7 +3165,7 @@ std::string NMD::BGEC(uint64 instruction)
 
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEC %s, %s, %s", rs, rt, s);
 }
@@ -3182,7 +3181,7 @@ std::string NMD::BGEC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BGEIC(uint64 instruction)
+std::string NMD::BGEIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3190,7 +3189,7 @@ std::string NMD::BGEIC(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEIC %s, %s, %s", rt, u, s);
 }
@@ -3206,7 +3205,7 @@ std::string NMD::BGEIC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BGEIUC(uint64 instruction)
+std::string NMD::BGEIUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3214,7 +3213,7 @@ std::string NMD::BGEIUC(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEIUC %s, %s, %s", rt, u, s);
 }
@@ -3230,7 +3229,7 @@ std::string NMD::BGEIUC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BGEUC(uint64 instruction)
+std::string NMD::BGEUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3238,7 +3237,7 @@ std::string NMD::BGEUC(uint64 instruction)
 
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEUC %s, %s, %s", rs, rt, s);
 }
@@ -3254,7 +3253,7 @@ std::string NMD::BGEUC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BLTC(uint64 instruction)
+std::string NMD::BLTC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3262,7 +3261,7 @@ std::string NMD::BLTC(uint64 instruction)
 
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTC %s, %s, %s", rs, rt, s);
 }
@@ -3278,7 +3277,7 @@ std::string NMD::BLTC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BLTIC(uint64 instruction)
+std::string NMD::BLTIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3286,7 +3285,7 @@ std::string NMD::BLTIC(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTIC %s, %s, %s", rt, u, s);
 }
@@ -3302,7 +3301,7 @@ std::string NMD::BLTIC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BLTIUC(uint64 instruction)
+std::string NMD::BLTIUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3310,7 +3309,7 @@ std::string NMD::BLTIUC(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTIUC %s, %s, %s", rt, u, s);
 }
@@ -3326,7 +3325,7 @@ std::string NMD::BLTIUC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BLTUC(uint64 instruction)
+std::string NMD::BLTUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3334,7 +3333,7 @@ std::string NMD::BLTUC(uint64 instruction)
 
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTUC %s, %s, %s", rs, rt, s);
 }
@@ -3350,7 +3349,7 @@ std::string NMD::BLTUC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BNEC_16_(uint64 instruction)
+std::string NMD::BNEC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -3358,7 +3357,7 @@ std::string NMD::BNEC_16_(uint64 instruction)
 
     std::string rs3 = GPR(encode_rs3_and_check_rs3_ge_rt3(rs3_value));
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string u = ADDRESS(encode_u_from_address(u_value), 2);
+    std::string u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
 
     return img_format("BNEC %s, %s, %s", rs3, rt3, u);
 }
@@ -3374,7 +3373,7 @@ std::string NMD::BNEC_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BNEC_32_(uint64 instruction)
+std::string NMD::BNEC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3382,7 +3381,7 @@ std::string NMD::BNEC_32_(uint64 instruction)
 
     std::string rs = GPR(copy(rs_value));
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BNEC %s, %s, %s", rs, rt, s);
 }
@@ -3398,7 +3397,7 @@ std::string NMD::BNEC_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BNEIC(uint64 instruction)
+std::string NMD::BNEIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3406,7 +3405,7 @@ std::string NMD::BNEIC(uint64 instruction)
 
     std::string rt = GPR(copy(rt_value));
     std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BNEIC %s, %s, %s", rt, u, s);
 }
@@ -3422,13 +3421,13 @@ std::string NMD::BNEIC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BNEZC_16_(uint64 instruction)
+std::string NMD::BNEZC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
 
     std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 2);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BNEZC %s, %s", rt3, s);
 }
@@ -3444,11 +3443,11 @@ std::string NMD::BNEZC_16_(uint64 instruction)
  *            s[13:1] -------------
  *                           s[14] -
  */
-std::string NMD::BPOSGE32C(uint64 instruction)
+std::string NMD::BPOSGE32C(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BPOSGE32C %s", s);
 }
@@ -3464,7 +3463,7 @@ std::string NMD::BPOSGE32C(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BREAK_16_(uint64 instruction)
+std::string NMD::BREAK_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
@@ -3484,7 +3483,7 @@ std::string NMD::BREAK_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BREAK_32_(uint64 instruction)
+std::string NMD::BREAK_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
@@ -3504,7 +3503,7 @@ std::string NMD::BREAK_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BRSC(uint64 instruction)
+std::string NMD::BRSC(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
@@ -3524,7 +3523,7 @@ std::string NMD::BRSC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CACHE(uint64 instruction)
+std::string NMD::CACHE(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3548,7 +3547,7 @@ std::string NMD::CACHE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CACHEE(uint64 instruction)
+std::string NMD::CACHEE(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3572,7 +3571,7 @@ std::string NMD::CACHEE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CEIL_L_D(uint64 instruction)
+std::string NMD::CEIL_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3594,7 +3593,7 @@ std::string NMD::CEIL_L_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CEIL_L_S(uint64 instruction)
+std::string NMD::CEIL_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3616,7 +3615,7 @@ std::string NMD::CEIL_L_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CEIL_W_D(uint64 instruction)
+std::string NMD::CEIL_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3638,7 +3637,7 @@ std::string NMD::CEIL_W_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CEIL_W_S(uint64 instruction)
+std::string NMD::CEIL_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3660,7 +3659,7 @@ std::string NMD::CEIL_W_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CFC1(uint64 instruction)
+std::string NMD::CFC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -3682,7 +3681,7 @@ std::string NMD::CFC1(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CFC2(uint64 instruction)
+std::string NMD::CFC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -3704,7 +3703,7 @@ std::string NMD::CFC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CLASS_D(uint64 instruction)
+std::string NMD::CLASS_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3726,7 +3725,7 @@ std::string NMD::CLASS_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CLASS_S(uint64 instruction)
+std::string NMD::CLASS_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3748,7 +3747,7 @@ std::string NMD::CLASS_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CLO(uint64 instruction)
+std::string NMD::CLO(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3770,7 +3769,7 @@ std::string NMD::CLO(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CLZ(uint64 instruction)
+std::string NMD::CLZ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3792,7 +3791,7 @@ std::string NMD::CLZ(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_AF_D(uint64 instruction)
+std::string NMD::CMP_AF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3816,7 +3815,7 @@ std::string NMD::CMP_AF_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_AF_S(uint64 instruction)
+std::string NMD::CMP_AF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3840,7 +3839,7 @@ std::string NMD::CMP_AF_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_EQ_D(uint64 instruction)
+std::string NMD::CMP_EQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3863,7 +3862,7 @@ std::string NMD::CMP_EQ_D(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMP_EQ_PH(uint64 instruction)
+std::string NMD::CMP_EQ_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3885,7 +3884,7 @@ std::string NMD::CMP_EQ_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_EQ_S(uint64 instruction)
+std::string NMD::CMP_EQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3909,7 +3908,7 @@ std::string NMD::CMP_EQ_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_LE_D(uint64 instruction)
+std::string NMD::CMP_LE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3932,7 +3931,7 @@ std::string NMD::CMP_LE_D(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMP_LE_PH(uint64 instruction)
+std::string NMD::CMP_LE_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3954,7 +3953,7 @@ std::string NMD::CMP_LE_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_LE_S(uint64 instruction)
+std::string NMD::CMP_LE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3978,7 +3977,7 @@ std::string NMD::CMP_LE_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_LT_D(uint64 instruction)
+std::string NMD::CMP_LT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4001,7 +4000,7 @@ std::string NMD::CMP_LT_D(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMP_LT_PH(uint64 instruction)
+std::string NMD::CMP_LT_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -4023,7 +4022,7 @@ std::string NMD::CMP_LT_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_LT_S(uint64 instruction)
+std::string NMD::CMP_LT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4047,7 +4046,7 @@ std::string NMD::CMP_LT_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_NE_D(uint64 instruction)
+std::string NMD::CMP_NE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4071,7 +4070,7 @@ std::string NMD::CMP_NE_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_NE_S(uint64 instruction)
+std::string NMD::CMP_NE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4095,7 +4094,7 @@ std::string NMD::CMP_NE_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_OR_D(uint64 instruction)
+std::string NMD::CMP_OR_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4119,7 +4118,7 @@ std::string NMD::CMP_OR_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_OR_S(uint64 instruction)
+std::string NMD::CMP_OR_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4143,7 +4142,7 @@ std::string NMD::CMP_OR_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SAF_D(uint64 instruction)
+std::string NMD::CMP_SAF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4167,7 +4166,7 @@ std::string NMD::CMP_SAF_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SAF_S(uint64 instruction)
+std::string NMD::CMP_SAF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4191,7 +4190,7 @@ std::string NMD::CMP_SAF_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SEQ_D(uint64 instruction)
+std::string NMD::CMP_SEQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4215,7 +4214,7 @@ std::string NMD::CMP_SEQ_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SEQ_S(uint64 instruction)
+std::string NMD::CMP_SEQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4239,7 +4238,7 @@ std::string NMD::CMP_SEQ_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SLE_D(uint64 instruction)
+std::string NMD::CMP_SLE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4263,7 +4262,7 @@ std::string NMD::CMP_SLE_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SLE_S(uint64 instruction)
+std::string NMD::CMP_SLE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4287,7 +4286,7 @@ std::string NMD::CMP_SLE_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SLT_D(uint64 instruction)
+std::string NMD::CMP_SLT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4311,7 +4310,7 @@ std::string NMD::CMP_SLT_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SLT_S(uint64 instruction)
+std::string NMD::CMP_SLT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4335,7 +4334,7 @@ std::string NMD::CMP_SLT_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SNE_D(uint64 instruction)
+std::string NMD::CMP_SNE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4359,7 +4358,7 @@ std::string NMD::CMP_SNE_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SNE_S(uint64 instruction)
+std::string NMD::CMP_SNE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4383,7 +4382,7 @@ std::string NMD::CMP_SNE_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SOR_D(uint64 instruction)
+std::string NMD::CMP_SOR_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4407,7 +4406,7 @@ std::string NMD::CMP_SOR_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SOR_S(uint64 instruction)
+std::string NMD::CMP_SOR_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4431,7 +4430,7 @@ std::string NMD::CMP_SOR_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUEQ_D(uint64 instruction)
+std::string NMD::CMP_SUEQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4455,7 +4454,7 @@ std::string NMD::CMP_SUEQ_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUEQ_S(uint64 instruction)
+std::string NMD::CMP_SUEQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4479,7 +4478,7 @@ std::string NMD::CMP_SUEQ_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SULE_D(uint64 instruction)
+std::string NMD::CMP_SULE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4503,7 +4502,7 @@ std::string NMD::CMP_SULE_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SULE_S(uint64 instruction)
+std::string NMD::CMP_SULE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4527,7 +4526,7 @@ std::string NMD::CMP_SULE_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SULT_D(uint64 instruction)
+std::string NMD::CMP_SULT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4551,7 +4550,7 @@ std::string NMD::CMP_SULT_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SULT_S(uint64 instruction)
+std::string NMD::CMP_SULT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4575,7 +4574,7 @@ std::string NMD::CMP_SULT_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUN_D(uint64 instruction)
+std::string NMD::CMP_SUN_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4599,7 +4598,7 @@ std::string NMD::CMP_SUN_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUNE_D(uint64 instruction)
+std::string NMD::CMP_SUNE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4623,7 +4622,7 @@ std::string NMD::CMP_SUNE_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUNE_S(uint64 instruction)
+std::string NMD::CMP_SUNE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4647,7 +4646,7 @@ std::string NMD::CMP_SUNE_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUN_S(uint64 instruction)
+std::string NMD::CMP_SUN_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4671,7 +4670,7 @@ std::string NMD::CMP_SUN_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UEQ_D(uint64 instruction)
+std::string NMD::CMP_UEQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4695,7 +4694,7 @@ std::string NMD::CMP_UEQ_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UEQ_S(uint64 instruction)
+std::string NMD::CMP_UEQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4719,7 +4718,7 @@ std::string NMD::CMP_UEQ_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_ULE_D(uint64 instruction)
+std::string NMD::CMP_ULE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4743,7 +4742,7 @@ std::string NMD::CMP_ULE_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_ULE_S(uint64 instruction)
+std::string NMD::CMP_ULE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4767,7 +4766,7 @@ std::string NMD::CMP_ULE_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_ULT_D(uint64 instruction)
+std::string NMD::CMP_ULT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4791,7 +4790,7 @@ std::string NMD::CMP_ULT_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_ULT_S(uint64 instruction)
+std::string NMD::CMP_ULT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4815,7 +4814,7 @@ std::string NMD::CMP_ULT_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UN_D(uint64 instruction)
+std::string NMD::CMP_UN_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4839,7 +4838,7 @@ std::string NMD::CMP_UN_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UNE_D(uint64 instruction)
+std::string NMD::CMP_UNE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4863,7 +4862,7 @@ std::string NMD::CMP_UNE_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UNE_S(uint64 instruction)
+std::string NMD::CMP_UNE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4887,7 +4886,7 @@ std::string NMD::CMP_UNE_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UN_S(uint64 instruction)
+std::string NMD::CMP_UN_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4912,7 +4911,7 @@ std::string NMD::CMP_UN_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGDU_EQ_QB(uint64 instruction)
+std::string NMD::CMPGDU_EQ_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -4937,7 +4936,7 @@ std::string NMD::CMPGDU_EQ_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGDU_LE_QB(uint64 instruction)
+std::string NMD::CMPGDU_LE_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -4962,7 +4961,7 @@ std::string NMD::CMPGDU_LE_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGDU_LT_QB(uint64 instruction)
+std::string NMD::CMPGDU_LT_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -4987,7 +4986,7 @@ std::string NMD::CMPGDU_LT_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGU_EQ_QB(uint64 instruction)
+std::string NMD::CMPGU_EQ_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5012,7 +5011,7 @@ std::string NMD::CMPGU_EQ_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGU_LE_QB(uint64 instruction)
+std::string NMD::CMPGU_LE_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5037,7 +5036,7 @@ std::string NMD::CMPGU_LE_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGU_LT_QB(uint64 instruction)
+std::string NMD::CMPGU_LT_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5061,7 +5060,7 @@ std::string NMD::CMPGU_LT_QB(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMPU_EQ_QB(uint64 instruction)
+std::string NMD::CMPU_EQ_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5083,7 +5082,7 @@ std::string NMD::CMPU_EQ_QB(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMPU_LE_QB(uint64 instruction)
+std::string NMD::CMPU_LE_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5105,7 +5104,7 @@ std::string NMD::CMPU_LE_QB(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMPU_LT_QB(uint64 instruction)
+std::string NMD::CMPU_LT_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5127,7 +5126,7 @@ std::string NMD::CMPU_LT_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::COP2_1(uint64 instruction)
+std::string NMD::COP2_1(uint64 instruction, img_address m_pc)
 {
     uint64 cofun_value = extract_cofun_25_24_23(instruction);
 
@@ -5147,7 +5146,7 @@ std::string NMD::COP2_1(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CTC1(uint64 instruction)
+std::string NMD::CTC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -5169,7 +5168,7 @@ std::string NMD::CTC1(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CTC2(uint64 instruction)
+std::string NMD::CTC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -5191,7 +5190,7 @@ std::string NMD::CTC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_D_L(uint64 instruction)
+std::string NMD::CVT_D_L(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5213,7 +5212,7 @@ std::string NMD::CVT_D_L(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_D_S(uint64 instruction)
+std::string NMD::CVT_D_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5235,7 +5234,7 @@ std::string NMD::CVT_D_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_D_W(uint64 instruction)
+std::string NMD::CVT_D_W(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5257,7 +5256,7 @@ std::string NMD::CVT_D_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_L_D(uint64 instruction)
+std::string NMD::CVT_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5279,7 +5278,7 @@ std::string NMD::CVT_L_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_L_S(uint64 instruction)
+std::string NMD::CVT_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5301,7 +5300,7 @@ std::string NMD::CVT_L_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_S_D(uint64 instruction)
+std::string NMD::CVT_S_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5323,7 +5322,7 @@ std::string NMD::CVT_S_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_S_L(uint64 instruction)
+std::string NMD::CVT_S_L(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5345,7 +5344,7 @@ std::string NMD::CVT_S_L(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_S_PL(uint64 instruction)
+std::string NMD::CVT_S_PL(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5367,7 +5366,7 @@ std::string NMD::CVT_S_PL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_S_PU(uint64 instruction)
+std::string NMD::CVT_S_PU(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5389,7 +5388,7 @@ std::string NMD::CVT_S_PU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_S_W(uint64 instruction)
+std::string NMD::CVT_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5411,7 +5410,7 @@ std::string NMD::CVT_S_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_W_D(uint64 instruction)
+std::string NMD::CVT_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5433,7 +5432,7 @@ std::string NMD::CVT_W_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_W_S(uint64 instruction)
+std::string NMD::CVT_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5455,7 +5454,7 @@ std::string NMD::CVT_W_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DADDIU_48_(uint64 instruction)
+std::string NMD::DADDIU_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -5477,7 +5476,7 @@ std::string NMD::DADDIU_48_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DADDIU_NEG_(uint64 instruction)
+std::string NMD::DADDIU_NEG_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5501,7 +5500,7 @@ std::string NMD::DADDIU_NEG_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DADDIU_U12_(uint64 instruction)
+std::string NMD::DADDIU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5525,7 +5524,7 @@ std::string NMD::DADDIU_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DADD(uint64 instruction)
+std::string NMD::DADD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5549,7 +5548,7 @@ std::string NMD::DADD(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DADDU(uint64 instruction)
+std::string NMD::DADDU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5573,7 +5572,7 @@ std::string NMD::DADDU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DCLO(uint64 instruction)
+std::string NMD::DCLO(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5595,7 +5594,7 @@ std::string NMD::DCLO(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DCLZ(uint64 instruction)
+std::string NMD::DCLZ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5617,7 +5616,7 @@ std::string NMD::DCLZ(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DDIV(uint64 instruction)
+std::string NMD::DDIV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5641,7 +5640,7 @@ std::string NMD::DDIV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DDIVU(uint64 instruction)
+std::string NMD::DDIVU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5665,7 +5664,7 @@ std::string NMD::DDIVU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DERET(uint64 instruction)
+std::string NMD::DERET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -5683,7 +5682,7 @@ std::string NMD::DERET(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DEXTM(uint64 instruction)
+std::string NMD::DEXTM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5709,7 +5708,7 @@ std::string NMD::DEXTM(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DEXT(uint64 instruction)
+std::string NMD::DEXT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5735,7 +5734,7 @@ std::string NMD::DEXT(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DEXTU(uint64 instruction)
+std::string NMD::DEXTU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5761,7 +5760,7 @@ std::string NMD::DEXTU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DINSM(uint64 instruction)
+std::string NMD::DINSM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5789,7 +5788,7 @@ std::string NMD::DINSM(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DINS(uint64 instruction)
+std::string NMD::DINS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5817,7 +5816,7 @@ std::string NMD::DINS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DINSU(uint64 instruction)
+std::string NMD::DINSU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5845,7 +5844,7 @@ std::string NMD::DINSU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DI(uint64 instruction)
+std::string NMD::DI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -5865,7 +5864,7 @@ std::string NMD::DI(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DIV(uint64 instruction)
+std::string NMD::DIV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5889,7 +5888,7 @@ std::string NMD::DIV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DIV_D(uint64 instruction)
+std::string NMD::DIV_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5913,7 +5912,7 @@ std::string NMD::DIV_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DIV_S(uint64 instruction)
+std::string NMD::DIV_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5937,7 +5936,7 @@ std::string NMD::DIV_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DIVU(uint64 instruction)
+std::string NMD::DIVU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5961,7 +5960,7 @@ std::string NMD::DIVU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DLSA(uint64 instruction)
+std::string NMD::DLSA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5987,7 +5986,7 @@ std::string NMD::DLSA(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DLUI_48_(uint64 instruction)
+std::string NMD::DLUI_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     uint64 u_value = extract_u_31_to_0__s32(instruction);
@@ -6009,7 +6008,7 @@ std::string NMD::DLUI_48_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMFC0(uint64 instruction)
+std::string NMD::DMFC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -6033,7 +6032,7 @@ std::string NMD::DMFC0(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMFC1(uint64 instruction)
+std::string NMD::DMFC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -6055,7 +6054,7 @@ std::string NMD::DMFC1(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMFC2(uint64 instruction)
+std::string NMD::DMFC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -6077,7 +6076,7 @@ std::string NMD::DMFC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMFGC0(uint64 instruction)
+std::string NMD::DMFGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -6101,7 +6100,7 @@ std::string NMD::DMFGC0(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMOD(uint64 instruction)
+std::string NMD::DMOD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6125,7 +6124,7 @@ std::string NMD::DMOD(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMODU(uint64 instruction)
+std::string NMD::DMODU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6149,7 +6148,7 @@ std::string NMD::DMODU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMTC0(uint64 instruction)
+std::string NMD::DMTC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -6173,7 +6172,7 @@ std::string NMD::DMTC0(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMTC1(uint64 instruction)
+std::string NMD::DMTC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -6195,7 +6194,7 @@ std::string NMD::DMTC1(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMTC2(uint64 instruction)
+std::string NMD::DMTC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -6217,7 +6216,7 @@ std::string NMD::DMTC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMTGC0(uint64 instruction)
+std::string NMD::DMTGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -6241,7 +6240,7 @@ std::string NMD::DMTGC0(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMT(uint64 instruction)
+std::string NMD::DMT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -6261,7 +6260,7 @@ std::string NMD::DMT(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMUH(uint64 instruction)
+std::string NMD::DMUH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6285,7 +6284,7 @@ std::string NMD::DMUH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMUHU(uint64 instruction)
+std::string NMD::DMUHU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6309,7 +6308,7 @@ std::string NMD::DMUHU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMUL(uint64 instruction)
+std::string NMD::DMUL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6333,7 +6332,7 @@ std::string NMD::DMUL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMULU(uint64 instruction)
+std::string NMD::DMULU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6358,7 +6357,7 @@ std::string NMD::DMULU(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::DPA_W_PH(uint64 instruction)
+std::string NMD::DPA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6382,7 +6381,7 @@ std::string NMD::DPA_W_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAQ_SA_L_W(uint64 instruction)
+std::string NMD::DPAQ_SA_L_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6406,7 +6405,7 @@ std::string NMD::DPAQ_SA_L_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAQ_S_W_PH(uint64 instruction)
+std::string NMD::DPAQ_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6430,7 +6429,7 @@ std::string NMD::DPAQ_S_W_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAQX_SA_W_PH(uint64 instruction)
+std::string NMD::DPAQX_SA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6454,7 +6453,7 @@ std::string NMD::DPAQX_SA_W_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAQX_S_W_PH(uint64 instruction)
+std::string NMD::DPAQX_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6478,7 +6477,7 @@ std::string NMD::DPAQX_S_W_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAU_H_QBL(uint64 instruction)
+std::string NMD::DPAU_H_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6502,7 +6501,7 @@ std::string NMD::DPAU_H_QBL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAU_H_QBR(uint64 instruction)
+std::string NMD::DPAU_H_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6526,7 +6525,7 @@ std::string NMD::DPAU_H_QBR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAX_W_PH(uint64 instruction)
+std::string NMD::DPAX_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6550,7 +6549,7 @@ std::string NMD::DPAX_W_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPS_W_PH(uint64 instruction)
+std::string NMD::DPS_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6574,7 +6573,7 @@ std::string NMD::DPS_W_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSQ_SA_L_W(uint64 instruction)
+std::string NMD::DPSQ_SA_L_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6598,7 +6597,7 @@ std::string NMD::DPSQ_SA_L_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSQ_S_W_PH(uint64 instruction)
+std::string NMD::DPSQ_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6622,7 +6621,7 @@ std::string NMD::DPSQ_S_W_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSQX_SA_W_PH(uint64 instruction)
+std::string NMD::DPSQX_SA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6646,7 +6645,7 @@ std::string NMD::DPSQX_SA_W_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSQX_S_W_PH(uint64 instruction)
+std::string NMD::DPSQX_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6670,7 +6669,7 @@ std::string NMD::DPSQX_S_W_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSU_H_QBL(uint64 instruction)
+std::string NMD::DPSU_H_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6694,7 +6693,7 @@ std::string NMD::DPSU_H_QBL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSU_H_QBR(uint64 instruction)
+std::string NMD::DPSU_H_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6718,7 +6717,7 @@ std::string NMD::DPSU_H_QBR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSX_W_PH(uint64 instruction)
+std::string NMD::DPSX_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6742,7 +6741,7 @@ std::string NMD::DPSX_W_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DROTR(uint64 instruction)
+std::string NMD::DROTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6766,7 +6765,7 @@ std::string NMD::DROTR(uint64 instruction)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DROTR32(uint64 instruction)
+std::string NMD::DROTR32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6790,7 +6789,7 @@ std::string NMD::DROTR32(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DROTRV(uint64 instruction)
+std::string NMD::DROTRV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6814,7 +6813,7 @@ std::string NMD::DROTRV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DROTX(uint64 instruction)
+std::string NMD::DROTX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6840,7 +6839,7 @@ std::string NMD::DROTX(uint64 instruction)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSLL(uint64 instruction)
+std::string NMD::DSLL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6864,7 +6863,7 @@ std::string NMD::DSLL(uint64 instruction)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSLL32(uint64 instruction)
+std::string NMD::DSLL32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6888,7 +6887,7 @@ std::string NMD::DSLL32(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DSLLV(uint64 instruction)
+std::string NMD::DSLLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6912,7 +6911,7 @@ std::string NMD::DSLLV(uint64 instruction)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSRA(uint64 instruction)
+std::string NMD::DSRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6936,7 +6935,7 @@ std::string NMD::DSRA(uint64 instruction)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSRA32(uint64 instruction)
+std::string NMD::DSRA32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6960,7 +6959,7 @@ std::string NMD::DSRA32(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DSRAV(uint64 instruction)
+std::string NMD::DSRAV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6984,7 +6983,7 @@ std::string NMD::DSRAV(uint64 instruction)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSRL(uint64 instruction)
+std::string NMD::DSRL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7008,7 +7007,7 @@ std::string NMD::DSRL(uint64 instruction)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSRL32(uint64 instruction)
+std::string NMD::DSRL32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7032,7 +7031,7 @@ std::string NMD::DSRL32(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DSRLV(uint64 instruction)
+std::string NMD::DSRLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7056,7 +7055,7 @@ std::string NMD::DSRLV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DSUB(uint64 instruction)
+std::string NMD::DSUB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7080,7 +7079,7 @@ std::string NMD::DSUB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DSUBU(uint64 instruction)
+std::string NMD::DSUBU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7104,7 +7103,7 @@ std::string NMD::DSUBU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DVPE(uint64 instruction)
+std::string NMD::DVPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7124,7 +7123,7 @@ std::string NMD::DVPE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DVP(uint64 instruction)
+std::string NMD::DVP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7144,7 +7143,7 @@ std::string NMD::DVP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EHB(uint64 instruction)
+std::string NMD::EHB(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -7162,7 +7161,7 @@ std::string NMD::EHB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EI(uint64 instruction)
+std::string NMD::EI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7182,7 +7181,7 @@ std::string NMD::EI(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EMT(uint64 instruction)
+std::string NMD::EMT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7202,7 +7201,7 @@ std::string NMD::EMT(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ERET(uint64 instruction)
+std::string NMD::ERET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -7220,7 +7219,7 @@ std::string NMD::ERET(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ERETNC(uint64 instruction)
+std::string NMD::ERETNC(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -7238,7 +7237,7 @@ std::string NMD::ERETNC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EVP(uint64 instruction)
+std::string NMD::EVP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7258,7 +7257,7 @@ std::string NMD::EVP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EVPE(uint64 instruction)
+std::string NMD::EVPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7278,7 +7277,7 @@ std::string NMD::EVPE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXT(uint64 instruction)
+std::string NMD::EXT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7304,7 +7303,7 @@ std::string NMD::EXT(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTD(uint64 instruction)
+std::string NMD::EXTD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7330,7 +7329,7 @@ std::string NMD::EXTD(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTD32(uint64 instruction)
+std::string NMD::EXTD32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7356,7 +7355,7 @@ std::string NMD::EXTD32(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTPDP(uint64 instruction)
+std::string NMD::EXTPDP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 size_value = extract_size_20_19_18_17_16(instruction);
@@ -7380,7 +7379,7 @@ std::string NMD::EXTPDP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTPDPV(uint64 instruction)
+std::string NMD::EXTPDPV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7404,7 +7403,7 @@ std::string NMD::EXTPDPV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTP(uint64 instruction)
+std::string NMD::EXTP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 size_value = extract_size_20_19_18_17_16(instruction);
@@ -7428,7 +7427,7 @@ std::string NMD::EXTP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTPV(uint64 instruction)
+std::string NMD::EXTPV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7453,7 +7452,7 @@ std::string NMD::EXTPV(uint64 instruction)
  *       shift -----
  *               ac --
  */
-std::string NMD::EXTR_RS_W(uint64 instruction)
+std::string NMD::EXTR_RS_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
@@ -7478,7 +7477,7 @@ std::string NMD::EXTR_RS_W(uint64 instruction)
  *       shift -----
  *               ac --
  */
-std::string NMD::EXTR_R_W(uint64 instruction)
+std::string NMD::EXTR_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
@@ -7503,7 +7502,7 @@ std::string NMD::EXTR_R_W(uint64 instruction)
  *       shift -----
  *               ac --
  */
-std::string NMD::EXTR_S_H(uint64 instruction)
+std::string NMD::EXTR_S_H(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
@@ -7528,7 +7527,7 @@ std::string NMD::EXTR_S_H(uint64 instruction)
  *       shift -----
  *               ac --
  */
-std::string NMD::EXTR_W(uint64 instruction)
+std::string NMD::EXTR_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
@@ -7553,7 +7552,7 @@ std::string NMD::EXTR_W(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::EXTRV_RS_W(uint64 instruction)
+std::string NMD::EXTRV_RS_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7578,7 +7577,7 @@ std::string NMD::EXTRV_RS_W(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::EXTRV_R_W(uint64 instruction)
+std::string NMD::EXTRV_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7603,7 +7602,7 @@ std::string NMD::EXTRV_R_W(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::EXTRV_S_H(uint64 instruction)
+std::string NMD::EXTRV_S_H(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7628,7 +7627,7 @@ std::string NMD::EXTRV_S_H(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::EXTRV_W(uint64 instruction)
+std::string NMD::EXTRV_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7653,7 +7652,7 @@ std::string NMD::EXTRV_W(uint64 instruction)
  *               rd -----
  *                 shift -----
  */
-std::string NMD::EXTW(uint64 instruction)
+std::string NMD::EXTW(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7679,7 +7678,7 @@ std::string NMD::EXTW(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::FLOOR_L_D(uint64 instruction)
+std::string NMD::FLOOR_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -7701,7 +7700,7 @@ std::string NMD::FLOOR_L_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::FLOOR_L_S(uint64 instruction)
+std::string NMD::FLOOR_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -7723,7 +7722,7 @@ std::string NMD::FLOOR_L_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::FLOOR_W_D(uint64 instruction)
+std::string NMD::FLOOR_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -7745,7 +7744,7 @@ std::string NMD::FLOOR_W_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::FLOOR_W_S(uint64 instruction)
+std::string NMD::FLOOR_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -7767,7 +7766,7 @@ std::string NMD::FLOOR_W_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::FORK(uint64 instruction)
+std::string NMD::FORK(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7791,7 +7790,7 @@ std::string NMD::FORK(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::HYPCALL(uint64 instruction)
+std::string NMD::HYPCALL(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
@@ -7811,7 +7810,7 @@ std::string NMD::HYPCALL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::HYPCALL_16_(uint64 instruction)
+std::string NMD::HYPCALL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
@@ -7831,7 +7830,7 @@ std::string NMD::HYPCALL_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::INS(uint64 instruction)
+std::string NMD::INS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7858,7 +7857,7 @@ std::string NMD::INS(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::INSV(uint64 instruction)
+std::string NMD::INSV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7880,7 +7879,7 @@ std::string NMD::INSV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::IRET(uint64 instruction)
+std::string NMD::IRET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -7898,7 +7897,7 @@ std::string NMD::IRET(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::JALRC_16_(uint64 instruction)
+std::string NMD::JALRC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
 
@@ -7918,7 +7917,7 @@ std::string NMD::JALRC_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::JALRC_32_(uint64 instruction)
+std::string NMD::JALRC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7940,7 +7939,7 @@ std::string NMD::JALRC_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::JALRC_HB(uint64 instruction)
+std::string NMD::JALRC_HB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7962,7 +7961,7 @@ std::string NMD::JALRC_HB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::JRC(uint64 instruction)
+std::string NMD::JRC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
 
@@ -7982,7 +7981,7 @@ std::string NMD::JRC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LB_16_(uint64 instruction)
+std::string NMD::LB_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -8006,7 +8005,7 @@ std::string NMD::LB_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LB_GP_(uint64 instruction)
+std::string NMD::LB_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
@@ -8028,7 +8027,7 @@ std::string NMD::LB_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LB_S9_(uint64 instruction)
+std::string NMD::LB_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8052,7 +8051,7 @@ std::string NMD::LB_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LB_U12_(uint64 instruction)
+std::string NMD::LB_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8076,7 +8075,7 @@ std::string NMD::LB_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBE(uint64 instruction)
+std::string NMD::LBE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8100,7 +8099,7 @@ std::string NMD::LBE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBU_16_(uint64 instruction)
+std::string NMD::LBU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -8124,7 +8123,7 @@ std::string NMD::LBU_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBU_GP_(uint64 instruction)
+std::string NMD::LBU_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
@@ -8146,7 +8145,7 @@ std::string NMD::LBU_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBU_S9_(uint64 instruction)
+std::string NMD::LBU_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8170,7 +8169,7 @@ std::string NMD::LBU_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBU_U12_(uint64 instruction)
+std::string NMD::LBU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8194,7 +8193,7 @@ std::string NMD::LBU_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBUE(uint64 instruction)
+std::string NMD::LBUE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8218,7 +8217,7 @@ std::string NMD::LBUE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBUX(uint64 instruction)
+std::string NMD::LBUX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8242,7 +8241,7 @@ std::string NMD::LBUX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBX(uint64 instruction)
+std::string NMD::LBX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8266,7 +8265,7 @@ std::string NMD::LBX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LD_GP_(uint64 instruction)
+std::string NMD::LD_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_3__s3(instruction);
@@ -8288,7 +8287,7 @@ std::string NMD::LD_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LD_S9_(uint64 instruction)
+std::string NMD::LD_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8312,7 +8311,7 @@ std::string NMD::LD_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LD_U12_(uint64 instruction)
+std::string NMD::LD_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8336,7 +8335,7 @@ std::string NMD::LD_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC1_GP_(uint64 instruction)
+std::string NMD::LDC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
@@ -8358,7 +8357,7 @@ std::string NMD::LDC1_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC1_S9_(uint64 instruction)
+std::string NMD::LDC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8382,7 +8381,7 @@ std::string NMD::LDC1_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC1_U12_(uint64 instruction)
+std::string NMD::LDC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8406,7 +8405,7 @@ std::string NMD::LDC1_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC1XS(uint64 instruction)
+std::string NMD::LDC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8430,7 +8429,7 @@ std::string NMD::LDC1XS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC1X(uint64 instruction)
+std::string NMD::LDC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8454,7 +8453,7 @@ std::string NMD::LDC1X(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC2(uint64 instruction)
+std::string NMD::LDC2(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8478,7 +8477,7 @@ std::string NMD::LDC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDM(uint64 instruction)
+std::string NMD::LDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8504,13 +8503,13 @@ std::string NMD::LDM(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDPC_48_(uint64 instruction)
+std::string NMD::LDPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 6);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("LDPC %s, %s", rt, s);
 }
@@ -8526,7 +8525,7 @@ std::string NMD::LDPC_48_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDX(uint64 instruction)
+std::string NMD::LDX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8550,7 +8549,7 @@ std::string NMD::LDX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDXS(uint64 instruction)
+std::string NMD::LDXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8574,7 +8573,7 @@ std::string NMD::LDXS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LH_16_(uint64 instruction)
+std::string NMD::LH_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -8598,7 +8597,7 @@ std::string NMD::LH_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LH_GP_(uint64 instruction)
+std::string NMD::LH_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
@@ -8620,7 +8619,7 @@ std::string NMD::LH_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LH_S9_(uint64 instruction)
+std::string NMD::LH_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8644,7 +8643,7 @@ std::string NMD::LH_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LH_U12_(uint64 instruction)
+std::string NMD::LH_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8668,7 +8667,7 @@ std::string NMD::LH_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHE(uint64 instruction)
+std::string NMD::LHE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8692,7 +8691,7 @@ std::string NMD::LHE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHU_16_(uint64 instruction)
+std::string NMD::LHU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -8716,7 +8715,7 @@ std::string NMD::LHU_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHU_GP_(uint64 instruction)
+std::string NMD::LHU_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
@@ -8738,7 +8737,7 @@ std::string NMD::LHU_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHU_S9_(uint64 instruction)
+std::string NMD::LHU_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8762,7 +8761,7 @@ std::string NMD::LHU_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHU_U12_(uint64 instruction)
+std::string NMD::LHU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8786,7 +8785,7 @@ std::string NMD::LHU_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHUE(uint64 instruction)
+std::string NMD::LHUE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8810,7 +8809,7 @@ std::string NMD::LHUE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHUX(uint64 instruction)
+std::string NMD::LHUX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8834,7 +8833,7 @@ std::string NMD::LHUX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHUXS(uint64 instruction)
+std::string NMD::LHUXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8858,7 +8857,7 @@ std::string NMD::LHUXS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHXS(uint64 instruction)
+std::string NMD::LHXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8882,7 +8881,7 @@ std::string NMD::LHXS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHX(uint64 instruction)
+std::string NMD::LHX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8906,7 +8905,7 @@ std::string NMD::LHX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LI_16_(uint64 instruction)
+std::string NMD::LI_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
@@ -8928,7 +8927,7 @@ std::string NMD::LI_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LI_48_(uint64 instruction)
+std::string NMD::LI_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -8950,7 +8949,7 @@ std::string NMD::LI_48_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LL(uint64 instruction)
+std::string NMD::LL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8974,7 +8973,7 @@ std::string NMD::LL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LLD(uint64 instruction)
+std::string NMD::LLD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8998,7 +8997,7 @@ std::string NMD::LLD(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LLDP(uint64 instruction)
+std::string NMD::LLDP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9022,7 +9021,7 @@ std::string NMD::LLDP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LLE(uint64 instruction)
+std::string NMD::LLE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9046,7 +9045,7 @@ std::string NMD::LLE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LLWP(uint64 instruction)
+std::string NMD::LLWP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9070,7 +9069,7 @@ std::string NMD::LLWP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LLWPE(uint64 instruction)
+std::string NMD::LLWPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9094,7 +9093,7 @@ std::string NMD::LLWPE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LSA(uint64 instruction)
+std::string NMD::LSA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9120,7 +9119,7 @@ std::string NMD::LSA(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LUI(uint64 instruction)
+std::string NMD::LUI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
@@ -9142,7 +9141,7 @@ std::string NMD::LUI(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_16_(uint64 instruction)
+std::string NMD::LW_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -9166,7 +9165,7 @@ std::string NMD::LW_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_4X4_(uint64 instruction)
+std::string NMD::LW_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
@@ -9190,7 +9189,7 @@ std::string NMD::LW_4X4_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_GP_(uint64 instruction)
+std::string NMD::LW_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
@@ -9212,7 +9211,7 @@ std::string NMD::LW_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_GP16_(uint64 instruction)
+std::string NMD::LW_GP16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
@@ -9234,7 +9233,7 @@ std::string NMD::LW_GP16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_S9_(uint64 instruction)
+std::string NMD::LW_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9258,7 +9257,7 @@ std::string NMD::LW_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_SP_(uint64 instruction)
+std::string NMD::LW_SP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
@@ -9280,7 +9279,7 @@ std::string NMD::LW_SP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_U12_(uint64 instruction)
+std::string NMD::LW_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9304,7 +9303,7 @@ std::string NMD::LW_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC1_GP_(uint64 instruction)
+std::string NMD::LWC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
@@ -9326,7 +9325,7 @@ std::string NMD::LWC1_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC1_S9_(uint64 instruction)
+std::string NMD::LWC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9350,7 +9349,7 @@ std::string NMD::LWC1_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC1_U12_(uint64 instruction)
+std::string NMD::LWC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9374,7 +9373,7 @@ std::string NMD::LWC1_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC1X(uint64 instruction)
+std::string NMD::LWC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9398,7 +9397,7 @@ std::string NMD::LWC1X(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC1XS(uint64 instruction)
+std::string NMD::LWC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9422,7 +9421,7 @@ std::string NMD::LWC1XS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC2(uint64 instruction)
+std::string NMD::LWC2(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9446,7 +9445,7 @@ std::string NMD::LWC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWE(uint64 instruction)
+std::string NMD::LWE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9470,7 +9469,7 @@ std::string NMD::LWE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWM(uint64 instruction)
+std::string NMD::LWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9496,13 +9495,13 @@ std::string NMD::LWM(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWPC_48_(uint64 instruction)
+std::string NMD::LWPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 6);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("LWPC %s, %s", rt, s);
 }
@@ -9518,7 +9517,7 @@ std::string NMD::LWPC_48_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWU_GP_(uint64 instruction)
+std::string NMD::LWU_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
@@ -9540,7 +9539,7 @@ std::string NMD::LWU_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWU_S9_(uint64 instruction)
+std::string NMD::LWU_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9564,7 +9563,7 @@ std::string NMD::LWU_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWU_U12_(uint64 instruction)
+std::string NMD::LWU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9588,7 +9587,7 @@ std::string NMD::LWU_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWUX(uint64 instruction)
+std::string NMD::LWUX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9612,7 +9611,7 @@ std::string NMD::LWUX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWUXS(uint64 instruction)
+std::string NMD::LWUXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9636,7 +9635,7 @@ std::string NMD::LWUXS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWX(uint64 instruction)
+std::string NMD::LWX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9660,7 +9659,7 @@ std::string NMD::LWX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWXS_16_(uint64 instruction)
+std::string NMD::LWXS_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -9684,7 +9683,7 @@ std::string NMD::LWXS_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWXS_32_(uint64 instruction)
+std::string NMD::LWXS_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9709,7 +9708,7 @@ std::string NMD::LWXS_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MADD_DSP_(uint64 instruction)
+std::string NMD::MADD_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9733,7 +9732,7 @@ std::string NMD::MADD_DSP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MADDF_D(uint64 instruction)
+std::string NMD::MADDF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -9757,7 +9756,7 @@ std::string NMD::MADDF_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MADDF_S(uint64 instruction)
+std::string NMD::MADDF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -9782,7 +9781,7 @@ std::string NMD::MADDF_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MADDU_DSP_(uint64 instruction)
+std::string NMD::MADDU_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9807,7 +9806,7 @@ std::string NMD::MADDU_DSP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAQ_S_W_PHL(uint64 instruction)
+std::string NMD::MAQ_S_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9832,7 +9831,7 @@ std::string NMD::MAQ_S_W_PHL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAQ_S_W_PHR(uint64 instruction)
+std::string NMD::MAQ_S_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9857,7 +9856,7 @@ std::string NMD::MAQ_S_W_PHR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAQ_SA_W_PHL(uint64 instruction)
+std::string NMD::MAQ_SA_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9882,7 +9881,7 @@ std::string NMD::MAQ_SA_W_PHL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAQ_SA_W_PHR(uint64 instruction)
+std::string NMD::MAQ_SA_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9906,7 +9905,7 @@ std::string NMD::MAQ_SA_W_PHR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAX_D(uint64 instruction)
+std::string NMD::MAX_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -9930,7 +9929,7 @@ std::string NMD::MAX_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAX_S(uint64 instruction)
+std::string NMD::MAX_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -9954,7 +9953,7 @@ std::string NMD::MAX_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAXA_D(uint64 instruction)
+std::string NMD::MAXA_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -9978,7 +9977,7 @@ std::string NMD::MAXA_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAXA_S(uint64 instruction)
+std::string NMD::MAXA_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10002,7 +10001,7 @@ std::string NMD::MAXA_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFC0(uint64 instruction)
+std::string NMD::MFC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10026,7 +10025,7 @@ std::string NMD::MFC0(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFC1(uint64 instruction)
+std::string NMD::MFC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10048,7 +10047,7 @@ std::string NMD::MFC1(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFC2(uint64 instruction)
+std::string NMD::MFC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -10070,7 +10069,7 @@ std::string NMD::MFC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFGC0(uint64 instruction)
+std::string NMD::MFGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10094,7 +10093,7 @@ std::string NMD::MFGC0(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFHC0(uint64 instruction)
+std::string NMD::MFHC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10118,7 +10117,7 @@ std::string NMD::MFHC0(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFHC1(uint64 instruction)
+std::string NMD::MFHC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10140,7 +10139,7 @@ std::string NMD::MFHC1(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFHC2(uint64 instruction)
+std::string NMD::MFHC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -10162,7 +10161,7 @@ std::string NMD::MFHC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFHGC0(uint64 instruction)
+std::string NMD::MFHGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10185,7 +10184,7 @@ std::string NMD::MFHGC0(uint64 instruction)
  *     rt -----
  *               ac --
  */
-std::string NMD::MFHI_DSP_(uint64 instruction)
+std::string NMD::MFHI_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -10207,7 +10206,7 @@ std::string NMD::MFHI_DSP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFHTR(uint64 instruction)
+std::string NMD::MFHTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10232,7 +10231,7 @@ std::string NMD::MFHTR(uint64 instruction)
  *     rt -----
  *               ac --
  */
-std::string NMD::MFLO_DSP_(uint64 instruction)
+std::string NMD::MFLO_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -10254,7 +10253,7 @@ std::string NMD::MFLO_DSP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFTR(uint64 instruction)
+std::string NMD::MFTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10280,7 +10279,7 @@ std::string NMD::MFTR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MIN_D(uint64 instruction)
+std::string NMD::MIN_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10304,7 +10303,7 @@ std::string NMD::MIN_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MIN_S(uint64 instruction)
+std::string NMD::MIN_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10328,7 +10327,7 @@ std::string NMD::MIN_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MINA_D(uint64 instruction)
+std::string NMD::MINA_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10352,7 +10351,7 @@ std::string NMD::MINA_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MINA_S(uint64 instruction)
+std::string NMD::MINA_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10376,7 +10375,7 @@ std::string NMD::MINA_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOD(uint64 instruction)
+std::string NMD::MOD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10400,7 +10399,7 @@ std::string NMD::MOD(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MODSUB(uint64 instruction)
+std::string NMD::MODSUB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10424,7 +10423,7 @@ std::string NMD::MODSUB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MODU(uint64 instruction)
+std::string NMD::MODU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10448,7 +10447,7 @@ std::string NMD::MODU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOV_D(uint64 instruction)
+std::string NMD::MOV_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10470,7 +10469,7 @@ std::string NMD::MOV_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOV_S(uint64 instruction)
+std::string NMD::MOV_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10492,7 +10491,7 @@ std::string NMD::MOV_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVE_BALC(uint64 instruction)
+std::string NMD::MOVE_BALC(uint64 instruction, img_address m_pc)
 {
     uint64 rtz4_value = extract_rtz4_27_26_25_23_22_21(instruction);
     uint64 rd1_value = extract_rdl_25_24(instruction);
@@ -10500,7 +10499,7 @@ std::string NMD::MOVE_BALC(uint64 instruction)
 
     std::string rd1 = GPR(decode_gpr_gpr1(rd1_value));
     std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
 }
@@ -10516,7 +10515,7 @@ std::string NMD::MOVE_BALC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVEP(uint64 instruction)
+std::string NMD::MOVEP(uint64 instruction, img_address m_pc)
 {
     uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
     uint64 rd2_value = extract_rd2_3_8(instruction);
@@ -10543,7 +10542,7 @@ std::string NMD::MOVEP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVEP_REV_(uint64 instruction)
+std::string NMD::MOVEP_REV_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rd2_value = extract_rd2_3_8(instruction);
@@ -10570,7 +10569,7 @@ std::string NMD::MOVEP_REV_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVE(uint64 instruction)
+std::string NMD::MOVE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
@@ -10592,7 +10591,7 @@ std::string NMD::MOVE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVN(uint64 instruction)
+std::string NMD::MOVN(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10616,7 +10615,7 @@ std::string NMD::MOVN(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVZ(uint64 instruction)
+std::string NMD::MOVZ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10640,7 +10639,7 @@ std::string NMD::MOVZ(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::MSUB_DSP_(uint64 instruction)
+std::string NMD::MSUB_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10664,7 +10663,7 @@ std::string NMD::MSUB_DSP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MSUBF_D(uint64 instruction)
+std::string NMD::MSUBF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10688,7 +10687,7 @@ std::string NMD::MSUBF_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MSUBF_S(uint64 instruction)
+std::string NMD::MSUBF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10712,7 +10711,7 @@ std::string NMD::MSUBF_S(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::MSUBU_DSP_(uint64 instruction)
+std::string NMD::MSUBU_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10736,7 +10735,7 @@ std::string NMD::MSUBU_DSP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTC0(uint64 instruction)
+std::string NMD::MTC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10760,7 +10759,7 @@ std::string NMD::MTC0(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTC1(uint64 instruction)
+std::string NMD::MTC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10782,7 +10781,7 @@ std::string NMD::MTC1(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTC2(uint64 instruction)
+std::string NMD::MTC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -10804,7 +10803,7 @@ std::string NMD::MTC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTGC0(uint64 instruction)
+std::string NMD::MTGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10828,7 +10827,7 @@ std::string NMD::MTGC0(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTHC0(uint64 instruction)
+std::string NMD::MTHC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10852,7 +10851,7 @@ std::string NMD::MTHC0(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTHC1(uint64 instruction)
+std::string NMD::MTHC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10874,7 +10873,7 @@ std::string NMD::MTHC1(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTHC2(uint64 instruction)
+std::string NMD::MTHC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -10896,7 +10895,7 @@ std::string NMD::MTHC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTHGC0(uint64 instruction)
+std::string NMD::MTHGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10919,7 +10918,7 @@ std::string NMD::MTHGC0(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::MTHI_DSP_(uint64 instruction)
+std::string NMD::MTHI_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -10940,7 +10939,7 @@ std::string NMD::MTHI_DSP_(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::MTHLIP(uint64 instruction)
+std::string NMD::MTHLIP(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -10962,7 +10961,7 @@ std::string NMD::MTHLIP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTHTR(uint64 instruction)
+std::string NMD::MTHTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10987,7 +10986,7 @@ std::string NMD::MTHTR(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::MTLO_DSP_(uint64 instruction)
+std::string NMD::MTLO_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -11009,7 +11008,7 @@ std::string NMD::MTLO_DSP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTTR(uint64 instruction)
+std::string NMD::MTTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -11035,7 +11034,7 @@ std::string NMD::MTTR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUH(uint64 instruction)
+std::string NMD::MUH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11059,7 +11058,7 @@ std::string NMD::MUH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUHU(uint64 instruction)
+std::string NMD::MUHU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11083,7 +11082,7 @@ std::string NMD::MUHU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_32_(uint64 instruction)
+std::string NMD::MUL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11107,7 +11106,7 @@ std::string NMD::MUL_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_4X4_(uint64 instruction)
+std::string NMD::MUL_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
@@ -11129,7 +11128,7 @@ std::string NMD::MUL_4X4_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_D(uint64 instruction)
+std::string NMD::MUL_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -11154,7 +11153,7 @@ std::string NMD::MUL_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_PH(uint64 instruction)
+std::string NMD::MUL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11179,7 +11178,7 @@ std::string NMD::MUL_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_S_PH(uint64 instruction)
+std::string NMD::MUL_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11203,7 +11202,7 @@ std::string NMD::MUL_S_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_S(uint64 instruction)
+std::string NMD::MUL_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -11228,7 +11227,7 @@ std::string NMD::MUL_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULEQ_S_W_PHL(uint64 instruction)
+std::string NMD::MULEQ_S_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11253,7 +11252,7 @@ std::string NMD::MULEQ_S_W_PHL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULEQ_S_W_PHR(uint64 instruction)
+std::string NMD::MULEQ_S_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11278,7 +11277,7 @@ std::string NMD::MULEQ_S_W_PHR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULEU_S_PH_QBL(uint64 instruction)
+std::string NMD::MULEU_S_PH_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11303,7 +11302,7 @@ std::string NMD::MULEU_S_PH_QBL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULEU_S_PH_QBR(uint64 instruction)
+std::string NMD::MULEU_S_PH_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11328,7 +11327,7 @@ std::string NMD::MULEU_S_PH_QBR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULQ_RS_PH(uint64 instruction)
+std::string NMD::MULQ_RS_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11353,7 +11352,7 @@ std::string NMD::MULQ_RS_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULQ_RS_W(uint64 instruction)
+std::string NMD::MULQ_RS_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11378,7 +11377,7 @@ std::string NMD::MULQ_RS_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULQ_S_PH(uint64 instruction)
+std::string NMD::MULQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11403,7 +11402,7 @@ std::string NMD::MULQ_S_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULQ_S_W(uint64 instruction)
+std::string NMD::MULQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11428,7 +11427,7 @@ std::string NMD::MULQ_S_W(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::MULSA_W_PH(uint64 instruction)
+std::string NMD::MULSA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11453,7 +11452,7 @@ std::string NMD::MULSA_W_PH(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::MULSAQ_S_W_PH(uint64 instruction)
+std::string NMD::MULSAQ_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11477,7 +11476,7 @@ std::string NMD::MULSAQ_S_W_PH(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::MULT_DSP_(uint64 instruction)
+std::string NMD::MULT_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11501,7 +11500,7 @@ std::string NMD::MULT_DSP_(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::MULTU_DSP_(uint64 instruction)
+std::string NMD::MULTU_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11525,7 +11524,7 @@ std::string NMD::MULTU_DSP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULU(uint64 instruction)
+std::string NMD::MULU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11549,7 +11548,7 @@ std::string NMD::MULU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NEG_D(uint64 instruction)
+std::string NMD::NEG_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -11571,7 +11570,7 @@ std::string NMD::NEG_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NEG_S(uint64 instruction)
+std::string NMD::NEG_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -11593,7 +11592,7 @@ std::string NMD::NEG_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NOP_16_(uint64 instruction)
+std::string NMD::NOP_16_(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -11611,7 +11610,7 @@ std::string NMD::NOP_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NOP_32_(uint64 instruction)
+std::string NMD::NOP_32_(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -11629,7 +11628,7 @@ std::string NMD::NOP_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NOR(uint64 instruction)
+std::string NMD::NOR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11653,7 +11652,7 @@ std::string NMD::NOR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NOT_16_(uint64 instruction)
+std::string NMD::NOT_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -11675,7 +11674,7 @@ std::string NMD::NOT_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::OR_16_(uint64 instruction)
+std::string NMD::OR_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -11697,7 +11696,7 @@ std::string NMD::OR_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::OR_32_(uint64 instruction)
+std::string NMD::OR_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11721,7 +11720,7 @@ std::string NMD::OR_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ORI(uint64 instruction)
+std::string NMD::ORI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11746,7 +11745,7 @@ std::string NMD::ORI(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PACKRL_PH(uint64 instruction)
+std::string NMD::PACKRL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11770,7 +11769,7 @@ std::string NMD::PACKRL_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PAUSE(uint64 instruction)
+std::string NMD::PAUSE(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -11789,7 +11788,7 @@ std::string NMD::PAUSE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PICK_PH(uint64 instruction)
+std::string NMD::PICK_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11814,7 +11813,7 @@ std::string NMD::PICK_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PICK_QB(uint64 instruction)
+std::string NMD::PICK_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11839,7 +11838,7 @@ std::string NMD::PICK_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQ_W_PHL(uint64 instruction)
+std::string NMD::PRECEQ_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11862,7 +11861,7 @@ std::string NMD::PRECEQ_W_PHL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQ_W_PHR(uint64 instruction)
+std::string NMD::PRECEQ_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11885,7 +11884,7 @@ std::string NMD::PRECEQ_W_PHR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQU_PH_QBLA(uint64 instruction)
+std::string NMD::PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11908,7 +11907,7 @@ std::string NMD::PRECEQU_PH_QBLA(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQU_PH_QBL(uint64 instruction)
+std::string NMD::PRECEQU_PH_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11931,7 +11930,7 @@ std::string NMD::PRECEQU_PH_QBL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQU_PH_QBRA(uint64 instruction)
+std::string NMD::PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11954,7 +11953,7 @@ std::string NMD::PRECEQU_PH_QBRA(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQU_PH_QBR(uint64 instruction)
+std::string NMD::PRECEQU_PH_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11978,7 +11977,7 @@ std::string NMD::PRECEQU_PH_QBR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEU_PH_QBLA(uint64 instruction)
+std::string NMD::PRECEU_PH_QBLA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12001,7 +12000,7 @@ std::string NMD::PRECEU_PH_QBLA(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEU_PH_QBL(uint64 instruction)
+std::string NMD::PRECEU_PH_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12025,7 +12024,7 @@ std::string NMD::PRECEU_PH_QBL(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEU_PH_QBRA(uint64 instruction)
+std::string NMD::PRECEU_PH_QBRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12048,7 +12047,7 @@ std::string NMD::PRECEU_PH_QBRA(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEU_PH_QBR(uint64 instruction)
+std::string NMD::PRECEU_PH_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12071,7 +12070,7 @@ std::string NMD::PRECEU_PH_QBR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECR_QB_PH(uint64 instruction)
+std::string NMD::PRECR_QB_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12096,7 +12095,7 @@ std::string NMD::PRECR_QB_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECR_SRA_PH_W(uint64 instruction)
+std::string NMD::PRECR_SRA_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12121,7 +12120,7 @@ std::string NMD::PRECR_SRA_PH_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECR_SRA_R_PH_W(uint64 instruction)
+std::string NMD::PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12146,7 +12145,7 @@ std::string NMD::PRECR_SRA_R_PH_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECRQ_PH_W(uint64 instruction)
+std::string NMD::PRECRQ_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12171,7 +12170,7 @@ std::string NMD::PRECRQ_PH_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECRQ_QB_PH(uint64 instruction)
+std::string NMD::PRECRQ_QB_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12196,7 +12195,7 @@ std::string NMD::PRECRQ_QB_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECRQ_RS_PH_W(uint64 instruction)
+std::string NMD::PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12221,7 +12220,7 @@ std::string NMD::PRECRQ_RS_PH_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECRQU_S_QB_PH(uint64 instruction)
+std::string NMD::PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12245,7 +12244,7 @@ std::string NMD::PRECRQU_S_QB_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PREF_S9_(uint64 instruction)
+std::string NMD::PREF_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12269,7 +12268,7 @@ std::string NMD::PREF_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PREF_U12_(uint64 instruction)
+std::string NMD::PREF_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12293,7 +12292,7 @@ std::string NMD::PREF_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PREFE(uint64 instruction)
+std::string NMD::PREFE(uint64 instruction, img_address m_pc)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12317,7 +12316,7 @@ std::string NMD::PREFE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PREPEND(uint64 instruction)
+std::string NMD::PREPEND(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12340,7 +12339,7 @@ std::string NMD::PREPEND(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::RADDU_W_QB(uint64 instruction)
+std::string NMD::RADDU_W_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12361,7 +12360,7 @@ std::string NMD::RADDU_W_QB(uint64 instruction)
  *     rt -----
  *        mask -------
  */
-std::string NMD::RDDSP(uint64 instruction)
+std::string NMD::RDDSP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
@@ -12383,7 +12382,7 @@ std::string NMD::RDDSP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RDHWR(uint64 instruction)
+std::string NMD::RDHWR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
@@ -12407,7 +12406,7 @@ std::string NMD::RDHWR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RDPGPR(uint64 instruction)
+std::string NMD::RDPGPR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12429,7 +12428,7 @@ std::string NMD::RDPGPR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RECIP_D(uint64 instruction)
+std::string NMD::RECIP_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12451,7 +12450,7 @@ std::string NMD::RECIP_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RECIP_S(uint64 instruction)
+std::string NMD::RECIP_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12473,7 +12472,7 @@ std::string NMD::RECIP_S(uint64 instruction)
  *     rt -----
  *           s ----------
  */
-std::string NMD::REPL_PH(uint64 instruction)
+std::string NMD::REPL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se9_20_19_18_17_16_15_14_13_12_11(instruction);
@@ -12495,7 +12494,7 @@ std::string NMD::REPL_PH(uint64 instruction)
  *     rt -----
  *           u --------
  */
-std::string NMD::REPL_QB(uint64 instruction)
+std::string NMD::REPL_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
@@ -12517,7 +12516,7 @@ std::string NMD::REPL_QB(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::REPLV_PH(uint64 instruction)
+std::string NMD::REPLV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12538,7 +12537,7 @@ std::string NMD::REPLV_PH(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::REPLV_QB(uint64 instruction)
+std::string NMD::REPLV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12560,7 +12559,7 @@ std::string NMD::REPLV_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RESTORE_32_(uint64 instruction)
+std::string NMD::RESTORE_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 count_value = extract_count_19_18_17_16(instruction);
@@ -12583,7 +12582,7 @@ std::string NMD::RESTORE_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RESTORE_JRC_16_(uint64 instruction)
+std::string NMD::RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt1_value = extract_rtl_11(instruction);
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
@@ -12605,7 +12604,7 @@ std::string NMD::RESTORE_JRC_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RESTORE_JRC_32_(uint64 instruction)
+std::string NMD::RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 count_value = extract_count_19_18_17_16(instruction);
@@ -12628,7 +12627,7 @@ std::string NMD::RESTORE_JRC_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RESTOREF(uint64 instruction)
+std::string NMD::RESTOREF(uint64 instruction, img_address m_pc)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
@@ -12650,7 +12649,7 @@ std::string NMD::RESTOREF(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RINT_D(uint64 instruction)
+std::string NMD::RINT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12672,7 +12671,7 @@ std::string NMD::RINT_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RINT_S(uint64 instruction)
+std::string NMD::RINT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12694,7 +12693,7 @@ std::string NMD::RINT_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROTR(uint64 instruction)
+std::string NMD::ROTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12718,7 +12717,7 @@ std::string NMD::ROTR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROTRV(uint64 instruction)
+std::string NMD::ROTRV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12742,7 +12741,7 @@ std::string NMD::ROTRV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROTX(uint64 instruction)
+std::string NMD::ROTX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12771,7 +12770,7 @@ std::string NMD::ROTX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROUND_L_D(uint64 instruction)
+std::string NMD::ROUND_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12793,7 +12792,7 @@ std::string NMD::ROUND_L_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROUND_L_S(uint64 instruction)
+std::string NMD::ROUND_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12815,7 +12814,7 @@ std::string NMD::ROUND_L_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROUND_W_D(uint64 instruction)
+std::string NMD::ROUND_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12837,7 +12836,7 @@ std::string NMD::ROUND_W_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROUND_W_S(uint64 instruction)
+std::string NMD::ROUND_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12859,7 +12858,7 @@ std::string NMD::ROUND_W_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RSQRT_D(uint64 instruction)
+std::string NMD::RSQRT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12881,7 +12880,7 @@ std::string NMD::RSQRT_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RSQRT_S(uint64 instruction)
+std::string NMD::RSQRT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12903,7 +12902,7 @@ std::string NMD::RSQRT_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SAVE_16_(uint64 instruction)
+std::string NMD::SAVE_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt1_value = extract_rtl_11(instruction);
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
@@ -12925,7 +12924,7 @@ std::string NMD::SAVE_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SAVE_32_(uint64 instruction)
+std::string NMD::SAVE_32_(uint64 instruction, img_address m_pc)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
@@ -12948,7 +12947,7 @@ std::string NMD::SAVE_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SAVEF(uint64 instruction)
+std::string NMD::SAVEF(uint64 instruction, img_address m_pc)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
@@ -12970,7 +12969,7 @@ std::string NMD::SAVEF(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SB_16_(uint64 instruction)
+std::string NMD::SB_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -12994,7 +12993,7 @@ std::string NMD::SB_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SB_GP_(uint64 instruction)
+std::string NMD::SB_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
@@ -13016,7 +13015,7 @@ std::string NMD::SB_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SB_S9_(uint64 instruction)
+std::string NMD::SB_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13040,7 +13039,7 @@ std::string NMD::SB_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SB_U12_(uint64 instruction)
+std::string NMD::SB_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13064,7 +13063,7 @@ std::string NMD::SB_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SBE(uint64 instruction)
+std::string NMD::SBE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13088,7 +13087,7 @@ std::string NMD::SBE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SBX(uint64 instruction)
+std::string NMD::SBX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13112,7 +13111,7 @@ std::string NMD::SBX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SC(uint64 instruction)
+std::string NMD::SC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13136,7 +13135,7 @@ std::string NMD::SC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SCD(uint64 instruction)
+std::string NMD::SCD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13160,7 +13159,7 @@ std::string NMD::SCD(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SCDP(uint64 instruction)
+std::string NMD::SCDP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13184,7 +13183,7 @@ std::string NMD::SCDP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SCE(uint64 instruction)
+std::string NMD::SCE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13208,7 +13207,7 @@ std::string NMD::SCE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SCWP(uint64 instruction)
+std::string NMD::SCWP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13232,7 +13231,7 @@ std::string NMD::SCWP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SCWPE(uint64 instruction)
+std::string NMD::SCWPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13256,7 +13255,7 @@ std::string NMD::SCWPE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SD_GP_(uint64 instruction)
+std::string NMD::SD_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_3__s3(instruction);
@@ -13278,7 +13277,7 @@ std::string NMD::SD_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SD_S9_(uint64 instruction)
+std::string NMD::SD_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13302,7 +13301,7 @@ std::string NMD::SD_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SD_U12_(uint64 instruction)
+std::string NMD::SD_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13326,7 +13325,7 @@ std::string NMD::SD_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDBBP_16_(uint64 instruction)
+std::string NMD::SDBBP_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
@@ -13346,7 +13345,7 @@ std::string NMD::SDBBP_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDBBP_32_(uint64 instruction)
+std::string NMD::SDBBP_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
@@ -13366,7 +13365,7 @@ std::string NMD::SDBBP_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC1_GP_(uint64 instruction)
+std::string NMD::SDC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
@@ -13388,7 +13387,7 @@ std::string NMD::SDC1_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC1_S9_(uint64 instruction)
+std::string NMD::SDC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13412,7 +13411,7 @@ std::string NMD::SDC1_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC1_U12_(uint64 instruction)
+std::string NMD::SDC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13436,7 +13435,7 @@ std::string NMD::SDC1_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC1X(uint64 instruction)
+std::string NMD::SDC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13460,7 +13459,7 @@ std::string NMD::SDC1X(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC1XS(uint64 instruction)
+std::string NMD::SDC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13484,7 +13483,7 @@ std::string NMD::SDC1XS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC2(uint64 instruction)
+std::string NMD::SDC2(uint64 instruction, img_address m_pc)
 {
     uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13508,7 +13507,7 @@ std::string NMD::SDC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDM(uint64 instruction)
+std::string NMD::SDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13534,13 +13533,13 @@ std::string NMD::SDM(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDPC_48_(uint64 instruction)
+std::string NMD::SDPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 6);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("SDPC %s, %s", rt, s);
 }
@@ -13556,7 +13555,7 @@ std::string NMD::SDPC_48_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDXS(uint64 instruction)
+std::string NMD::SDXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13580,7 +13579,7 @@ std::string NMD::SDXS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDX(uint64 instruction)
+std::string NMD::SDX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13604,7 +13603,7 @@ std::string NMD::SDX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SEB(uint64 instruction)
+std::string NMD::SEB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13626,7 +13625,7 @@ std::string NMD::SEB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SEH(uint64 instruction)
+std::string NMD::SEH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13648,7 +13647,7 @@ std::string NMD::SEH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SEL_D(uint64 instruction)
+std::string NMD::SEL_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13672,7 +13671,7 @@ std::string NMD::SEL_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SEL_S(uint64 instruction)
+std::string NMD::SEL_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13696,7 +13695,7 @@ std::string NMD::SEL_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SELEQZ_D(uint64 instruction)
+std::string NMD::SELEQZ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13720,7 +13719,7 @@ std::string NMD::SELEQZ_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SELEQZ_S(uint64 instruction)
+std::string NMD::SELEQZ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13744,7 +13743,7 @@ std::string NMD::SELEQZ_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SELNEZ_D(uint64 instruction)
+std::string NMD::SELNEZ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13768,7 +13767,7 @@ std::string NMD::SELNEZ_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SELNEZ_S(uint64 instruction)
+std::string NMD::SELNEZ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13792,7 +13791,7 @@ std::string NMD::SELNEZ_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SEQI(uint64 instruction)
+std::string NMD::SEQI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13816,7 +13815,7 @@ std::string NMD::SEQI(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SH_16_(uint64 instruction)
+std::string NMD::SH_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -13840,7 +13839,7 @@ std::string NMD::SH_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SH_GP_(uint64 instruction)
+std::string NMD::SH_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
@@ -13862,7 +13861,7 @@ std::string NMD::SH_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SH_S9_(uint64 instruction)
+std::string NMD::SH_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13886,7 +13885,7 @@ std::string NMD::SH_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SH_U12_(uint64 instruction)
+std::string NMD::SH_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13910,7 +13909,7 @@ std::string NMD::SH_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHE(uint64 instruction)
+std::string NMD::SHE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13934,7 +13933,7 @@ std::string NMD::SHE(uint64 instruction)
  *      shift ------
  *               ac --
  */
-std::string NMD::SHILO(uint64 instruction)
+std::string NMD::SHILO(uint64 instruction, img_address m_pc)
 {
     int64 shift_value = extract_shift__se5_21_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -13956,7 +13955,7 @@ std::string NMD::SHILO(uint64 instruction)
  *          rs -----
  *               ac --
  */
-std::string NMD::SHILOV(uint64 instruction)
+std::string NMD::SHILOV(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -13978,7 +13977,7 @@ std::string NMD::SHILOV(uint64 instruction)
  *          rs -----
  *               sa ----
  */
-std::string NMD::SHLL_PH(uint64 instruction)
+std::string NMD::SHLL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14002,7 +14001,7 @@ std::string NMD::SHLL_PH(uint64 instruction)
  *          rs -----
  *               sa ---
  */
-std::string NMD::SHLL_QB(uint64 instruction)
+std::string NMD::SHLL_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14027,7 +14026,7 @@ std::string NMD::SHLL_QB(uint64 instruction)
  *          rs -----
  *               sa ----
  */
-std::string NMD::SHLL_S_PH(uint64 instruction)
+std::string NMD::SHLL_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14051,7 +14050,7 @@ std::string NMD::SHLL_S_PH(uint64 instruction)
  *          rs -----
  *               sa -----
  */
-std::string NMD::SHLL_S_W(uint64 instruction)
+std::string NMD::SHLL_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14076,7 +14075,7 @@ std::string NMD::SHLL_S_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHLLV_PH(uint64 instruction)
+std::string NMD::SHLLV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14100,7 +14099,7 @@ std::string NMD::SHLLV_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHLLV_QB(uint64 instruction)
+std::string NMD::SHLLV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14125,7 +14124,7 @@ std::string NMD::SHLLV_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHLLV_S_PH(uint64 instruction)
+std::string NMD::SHLLV_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14149,7 +14148,7 @@ std::string NMD::SHLLV_S_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHLLV_S_W(uint64 instruction)
+std::string NMD::SHLLV_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14173,7 +14172,7 @@ std::string NMD::SHLLV_S_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRA_PH(uint64 instruction)
+std::string NMD::SHRA_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14197,7 +14196,7 @@ std::string NMD::SHRA_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRA_QB(uint64 instruction)
+std::string NMD::SHRA_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14221,7 +14220,7 @@ std::string NMD::SHRA_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRA_R_PH(uint64 instruction)
+std::string NMD::SHRA_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14245,7 +14244,7 @@ std::string NMD::SHRA_R_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRA_R_QB(uint64 instruction)
+std::string NMD::SHRA_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14269,7 +14268,7 @@ std::string NMD::SHRA_R_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRA_R_W(uint64 instruction)
+std::string NMD::SHRA_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14293,7 +14292,7 @@ std::string NMD::SHRA_R_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRAV_PH(uint64 instruction)
+std::string NMD::SHRAV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14317,7 +14316,7 @@ std::string NMD::SHRAV_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRAV_QB(uint64 instruction)
+std::string NMD::SHRAV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14341,7 +14340,7 @@ std::string NMD::SHRAV_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRAV_R_PH(uint64 instruction)
+std::string NMD::SHRAV_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14365,7 +14364,7 @@ std::string NMD::SHRAV_R_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRAV_R_QB(uint64 instruction)
+std::string NMD::SHRAV_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14389,7 +14388,7 @@ std::string NMD::SHRAV_R_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRAV_R_W(uint64 instruction)
+std::string NMD::SHRAV_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14413,7 +14412,7 @@ std::string NMD::SHRAV_R_W(uint64 instruction)
  *          rs -----
  *               sa ----
  */
-std::string NMD::SHRL_PH(uint64 instruction)
+std::string NMD::SHRL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14437,7 +14436,7 @@ std::string NMD::SHRL_PH(uint64 instruction)
  *          rs -----
  *               sa ---
  */
-std::string NMD::SHRL_QB(uint64 instruction)
+std::string NMD::SHRL_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14462,7 +14461,7 @@ std::string NMD::SHRL_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRLV_PH(uint64 instruction)
+std::string NMD::SHRLV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14486,7 +14485,7 @@ std::string NMD::SHRLV_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRLV_QB(uint64 instruction)
+std::string NMD::SHRLV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14510,7 +14509,7 @@ std::string NMD::SHRLV_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHX(uint64 instruction)
+std::string NMD::SHX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14534,7 +14533,7 @@ std::string NMD::SHX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHXS(uint64 instruction)
+std::string NMD::SHXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14558,7 +14557,7 @@ std::string NMD::SHXS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SIGRIE(uint64 instruction)
+std::string NMD::SIGRIE(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
@@ -14578,7 +14577,7 @@ std::string NMD::SIGRIE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLL_16_(uint64 instruction)
+std::string NMD::SLL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -14602,7 +14601,7 @@ std::string NMD::SLL_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLL_32_(uint64 instruction)
+std::string NMD::SLL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14626,7 +14625,7 @@ std::string NMD::SLL_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLLV(uint64 instruction)
+std::string NMD::SLLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14650,7 +14649,7 @@ std::string NMD::SLLV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLT(uint64 instruction)
+std::string NMD::SLT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14674,7 +14673,7 @@ std::string NMD::SLT(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLTI(uint64 instruction)
+std::string NMD::SLTI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14698,7 +14697,7 @@ std::string NMD::SLTI(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLTIU(uint64 instruction)
+std::string NMD::SLTIU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14722,7 +14721,7 @@ std::string NMD::SLTIU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLTU(uint64 instruction)
+std::string NMD::SLTU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14746,7 +14745,7 @@ std::string NMD::SLTU(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SOV(uint64 instruction)
+std::string NMD::SOV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14770,7 +14769,7 @@ std::string NMD::SOV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SPECIAL2(uint64 instruction)
+std::string NMD::SPECIAL2(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
@@ -14790,7 +14789,7 @@ std::string NMD::SPECIAL2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SQRT_D(uint64 instruction)
+std::string NMD::SQRT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -14812,7 +14811,7 @@ std::string NMD::SQRT_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SQRT_S(uint64 instruction)
+std::string NMD::SQRT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -14834,7 +14833,7 @@ std::string NMD::SQRT_S(uint64 instruction)
  *               rd -----
  *                    sa -----
  */
-std::string NMD::SRA(uint64 instruction)
+std::string NMD::SRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14858,7 +14857,7 @@ std::string NMD::SRA(uint64 instruction)
  *          rt -----
  *               rd -----
  */
-std::string NMD::SRAV(uint64 instruction)
+std::string NMD::SRAV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14882,7 +14881,7 @@ std::string NMD::SRAV(uint64 instruction)
  *          rt -----
  *               rd -----
  */
-std::string NMD::SRL_16_(uint64 instruction)
+std::string NMD::SRL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -14906,7 +14905,7 @@ std::string NMD::SRL_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SRL_32_(uint64 instruction)
+std::string NMD::SRL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14930,7 +14929,7 @@ std::string NMD::SRL_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SRLV(uint64 instruction)
+std::string NMD::SRLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14954,7 +14953,7 @@ std::string NMD::SRLV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUB(uint64 instruction)
+std::string NMD::SUB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14978,7 +14977,7 @@ std::string NMD::SUB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUB_D(uint64 instruction)
+std::string NMD::SUB_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -15002,7 +15001,7 @@ std::string NMD::SUB_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUB_S(uint64 instruction)
+std::string NMD::SUB_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -15026,7 +15025,7 @@ std::string NMD::SUB_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQ_PH(uint64 instruction)
+std::string NMD::SUBQ_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15051,7 +15050,7 @@ std::string NMD::SUBQ_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQ_S_PH(uint64 instruction)
+std::string NMD::SUBQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15076,7 +15075,7 @@ std::string NMD::SUBQ_S_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQ_S_W(uint64 instruction)
+std::string NMD::SUBQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15101,7 +15100,7 @@ std::string NMD::SUBQ_S_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQH_PH(uint64 instruction)
+std::string NMD::SUBQH_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15126,7 +15125,7 @@ std::string NMD::SUBQH_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQH_R_PH(uint64 instruction)
+std::string NMD::SUBQH_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15151,7 +15150,7 @@ std::string NMD::SUBQH_R_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQH_R_W(uint64 instruction)
+std::string NMD::SUBQH_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15176,7 +15175,7 @@ std::string NMD::SUBQH_R_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQH_W(uint64 instruction)
+std::string NMD::SUBQH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15200,7 +15199,7 @@ std::string NMD::SUBQH_W(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_16_(uint64 instruction)
+std::string NMD::SUBU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -15224,7 +15223,7 @@ std::string NMD::SUBU_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_32_(uint64 instruction)
+std::string NMD::SUBU_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15248,7 +15247,7 @@ std::string NMD::SUBU_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_PH(uint64 instruction)
+std::string NMD::SUBU_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15272,7 +15271,7 @@ std::string NMD::SUBU_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_QB(uint64 instruction)
+std::string NMD::SUBU_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15297,7 +15296,7 @@ std::string NMD::SUBU_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_S_PH(uint64 instruction)
+std::string NMD::SUBU_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15322,7 +15321,7 @@ std::string NMD::SUBU_S_PH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_S_QB(uint64 instruction)
+std::string NMD::SUBU_S_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15347,7 +15346,7 @@ std::string NMD::SUBU_S_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBUH_QB(uint64 instruction)
+std::string NMD::SUBUH_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15372,7 +15371,7 @@ std::string NMD::SUBUH_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBUH_R_QB(uint64 instruction)
+std::string NMD::SUBUH_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15396,7 +15395,7 @@ std::string NMD::SUBUH_R_QB(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_16_(uint64 instruction)
+std::string NMD::SW_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -15420,7 +15419,7 @@ std::string NMD::SW_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_4X4_(uint64 instruction)
+std::string NMD::SW_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
@@ -15444,7 +15443,7 @@ std::string NMD::SW_4X4_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_GP16_(uint64 instruction)
+std::string NMD::SW_GP16_(uint64 instruction, img_address m_pc)
 {
     uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
@@ -15466,7 +15465,7 @@ std::string NMD::SW_GP16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_GP_(uint64 instruction)
+std::string NMD::SW_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
@@ -15488,7 +15487,7 @@ std::string NMD::SW_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_S9_(uint64 instruction)
+std::string NMD::SW_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
@@ -15512,7 +15511,7 @@ std::string NMD::SW_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_SP_(uint64 instruction)
+std::string NMD::SW_SP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
@@ -15534,7 +15533,7 @@ std::string NMD::SW_SP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_U12_(uint64 instruction)
+std::string NMD::SW_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15558,7 +15557,7 @@ std::string NMD::SW_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC1_GP_(uint64 instruction)
+std::string NMD::SWC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
@@ -15580,7 +15579,7 @@ std::string NMD::SWC1_GP_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC1_S9_(uint64 instruction)
+std::string NMD::SWC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15604,7 +15603,7 @@ std::string NMD::SWC1_S9_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC1_U12_(uint64 instruction)
+std::string NMD::SWC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15628,7 +15627,7 @@ std::string NMD::SWC1_U12_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC1X(uint64 instruction)
+std::string NMD::SWC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15652,7 +15651,7 @@ std::string NMD::SWC1X(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC1XS(uint64 instruction)
+std::string NMD::SWC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15676,7 +15675,7 @@ std::string NMD::SWC1XS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC2(uint64 instruction)
+std::string NMD::SWC2(uint64 instruction, img_address m_pc)
 {
     uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15700,7 +15699,7 @@ std::string NMD::SWC2(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWE(uint64 instruction)
+std::string NMD::SWE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15724,7 +15723,7 @@ std::string NMD::SWE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWM(uint64 instruction)
+std::string NMD::SWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15750,13 +15749,13 @@ std::string NMD::SWM(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWPC_48_(uint64 instruction)
+std::string NMD::SWPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 6);
+    std::string s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("SWPC %s, %s", rt, s);
 }
@@ -15772,7 +15771,7 @@ std::string NMD::SWPC_48_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWX(uint64 instruction)
+std::string NMD::SWX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15796,7 +15795,7 @@ std::string NMD::SWX(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWXS(uint64 instruction)
+std::string NMD::SWXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15820,7 +15819,7 @@ std::string NMD::SWXS(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SYNC(uint64 instruction)
+std::string NMD::SYNC(uint64 instruction, img_address m_pc)
 {
     uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
 
@@ -15840,7 +15839,7 @@ std::string NMD::SYNC(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SYNCI(uint64 instruction)
+std::string NMD::SYNCI(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
@@ -15862,7 +15861,7 @@ std::string NMD::SYNCI(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SYNCIE(uint64 instruction)
+std::string NMD::SYNCIE(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
@@ -15884,7 +15883,7 @@ std::string NMD::SYNCIE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SYSCALL_16_(uint64 instruction)
+std::string NMD::SYSCALL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
@@ -15902,7 +15901,7 @@ std::string NMD::SYSCALL_16_(uint64 instruction)
  *  00000000000010
  *           code ------------------
  */
-std::string NMD::SYSCALL_32_(uint64 instruction)
+std::string NMD::SYSCALL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
@@ -15922,7 +15921,7 @@ std::string NMD::SYSCALL_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TEQ(uint64 instruction)
+std::string NMD::TEQ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15944,7 +15943,7 @@ std::string NMD::TEQ(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGINV(uint64 instruction)
+std::string NMD::TLBGINV(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -15962,7 +15961,7 @@ std::string NMD::TLBGINV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGINVF(uint64 instruction)
+std::string NMD::TLBGINVF(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -15980,7 +15979,7 @@ std::string NMD::TLBGINVF(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGP(uint64 instruction)
+std::string NMD::TLBGP(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -15998,7 +15997,7 @@ std::string NMD::TLBGP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGR(uint64 instruction)
+std::string NMD::TLBGR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16016,7 +16015,7 @@ std::string NMD::TLBGR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGWI(uint64 instruction)
+std::string NMD::TLBGWI(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16034,7 +16033,7 @@ std::string NMD::TLBGWI(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGWR(uint64 instruction)
+std::string NMD::TLBGWR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16052,7 +16051,7 @@ std::string NMD::TLBGWR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBINV(uint64 instruction)
+std::string NMD::TLBINV(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16070,7 +16069,7 @@ std::string NMD::TLBINV(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBINVF(uint64 instruction)
+std::string NMD::TLBINVF(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16088,7 +16087,7 @@ std::string NMD::TLBINVF(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBP(uint64 instruction)
+std::string NMD::TLBP(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16106,7 +16105,7 @@ std::string NMD::TLBP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBR(uint64 instruction)
+std::string NMD::TLBR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16124,7 +16123,7 @@ std::string NMD::TLBR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBWI(uint64 instruction)
+std::string NMD::TLBWI(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16142,7 +16141,7 @@ std::string NMD::TLBWI(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBWR(uint64 instruction)
+std::string NMD::TLBWR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16160,7 +16159,7 @@ std::string NMD::TLBWR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TNE(uint64 instruction)
+std::string NMD::TNE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16182,7 +16181,7 @@ std::string NMD::TNE(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TRUNC_L_D(uint64 instruction)
+std::string NMD::TRUNC_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -16204,7 +16203,7 @@ std::string NMD::TRUNC_L_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TRUNC_L_S(uint64 instruction)
+std::string NMD::TRUNC_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -16226,7 +16225,7 @@ std::string NMD::TRUNC_L_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TRUNC_W_D(uint64 instruction)
+std::string NMD::TRUNC_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -16248,7 +16247,7 @@ std::string NMD::TRUNC_W_D(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TRUNC_W_S(uint64 instruction)
+std::string NMD::TRUNC_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -16270,7 +16269,7 @@ std::string NMD::TRUNC_W_S(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UALDM(uint64 instruction)
+std::string NMD::UALDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16296,7 +16295,7 @@ std::string NMD::UALDM(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UALH(uint64 instruction)
+std::string NMD::UALH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16320,7 +16319,7 @@ std::string NMD::UALH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UALWM(uint64 instruction)
+std::string NMD::UALWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16346,7 +16345,7 @@ std::string NMD::UALWM(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UASDM(uint64 instruction)
+std::string NMD::UASDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16372,7 +16371,7 @@ std::string NMD::UASDM(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UASH(uint64 instruction)
+std::string NMD::UASH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16396,7 +16395,7 @@ std::string NMD::UASH(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UASWM(uint64 instruction)
+std::string NMD::UASWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16422,7 +16421,7 @@ std::string NMD::UASWM(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UDI(uint64 instruction)
+std::string NMD::UDI(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
@@ -16440,7 +16439,7 @@ std::string NMD::UDI(uint64 instruction)
  *  001000          1100001101111111
  *   code ----------
  */
-std::string NMD::WAIT(uint64 instruction)
+std::string NMD::WAIT(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
 
@@ -16460,7 +16459,7 @@ std::string NMD::WAIT(uint64 instruction)
  *     rt -----
  *        mask -------
  */
-std::string NMD::WRDSP(uint64 instruction)
+std::string NMD::WRDSP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
@@ -16482,7 +16481,7 @@ std::string NMD::WRDSP(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::WRPGPR(uint64 instruction)
+std::string NMD::WRPGPR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16504,7 +16503,7 @@ std::string NMD::WRPGPR(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::XOR_16_(uint64 instruction)
+std::string NMD::XOR_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -16526,7 +16525,7 @@ std::string NMD::XOR_16_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::XOR_32_(uint64 instruction)
+std::string NMD::XOR_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16550,7 +16549,7 @@ std::string NMD::XOR_32_(uint64 instruction)
  *          rs -----
  *               rd -----
  */
-std::string NMD::XORI(uint64 instruction)
+std::string NMD::XORI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16573,7 +16572,7 @@ std::string NMD::XORI(uint64 instruction)
  *     rt -----
  *          rs -----
  */
-std::string NMD::YIELD(uint64 instruction)
+std::string NMD::YIELD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
diff --git a/disas/nanomips.h b/disas/nanomips.h
index f65a0957b8..4f9ac4b9ab 100644
--- a/disas/nanomips.h
+++ b/disas/nanomips.h
@@ -65,21 +65,13 @@ class NMD
 {
 public:
 
-    NMD(img_address pc, TABLE_ATTRIBUTE_TYPE requested_instruction_categories)
-        : m_pc(pc)
-        , m_requested_instruction_categories(requested_instruction_categories)
-    {
-    }
-
     int Disassemble(const uint16 *data, std::string & dis,
-                    TABLE_ENTRY_TYPE & type);
+                    TABLE_ENTRY_TYPE & type, img_address m_pc);
 
 private:
 
-    img_address           m_pc;
-    TABLE_ATTRIBUTE_TYPE   m_requested_instruction_categories;
-
-    typedef std::string(NMD:: *disassembly_function)(uint64 instruction);
+    typedef std::string(NMD:: *disassembly_function)(uint64 instruction,
+                                                     img_address m_pc);
     typedef bool(NMD:: *conditional_function)(uint64 instruction);
 
     struct Pool {
@@ -96,7 +88,8 @@ private:
 
     uint64 extract_op_code_value(const uint16 *data, int size);
     int Disassemble(const uint16 *data, std::string & dis,
-                    TABLE_ENTRY_TYPE & type, const Pool *table, int table_size);
+                    TABLE_ENTRY_TYPE & type, const Pool *table,
+                    int table_size, img_address m_pc);
 
     uint64 renumber_registers(uint64 index, uint64 *register_list,
                               size_t register_list_size);
@@ -137,7 +130,7 @@ private:
     std::string IMMEDIATE(uint64 value);
     std::string IMMEDIATE(int64 value);
     std::string CPR(uint64 reg);
-    std::string ADDRESS(uint64 value, int instruction_size);
+    std::string ADDRESS(uint64 value, int instruction_size, img_address m_pc);
 
     int64 extract_s__se3_4_2_1_0(uint64 instruction);
     int64 extract_s__se7_0_6_5_4_3_2_1_s1(uint64 instruction);
@@ -253,642 +246,642 @@ private:
     bool PREFE_cond(uint64 instruction);
     bool SLTU_cond(uint64 instruction);
 
-    std::string ABS_D(uint64 instruction);
-    std::string ABS_S(uint64 instruction);
-    std::string ABSQ_S_PH(uint64 instruction);
-    std::string ABSQ_S_QB(uint64 instruction);
-    std::string ABSQ_S_W(uint64 instruction);
-    std::string ACLR(uint64 instruction);
-    std::string ADD(uint64 instruction);
-    std::string ADD_D(uint64 instruction);
-    std::string ADD_S(uint64 instruction);
-    std::string ADDIU_32_(uint64 instruction);
-    std::string ADDIU_48_(uint64 instruction);
-    std::string ADDIU_GP48_(uint64 instruction);
-    std::string ADDIU_GP_B_(uint64 instruction);
-    std::string ADDIU_GP_W_(uint64 instruction);
-    std::string ADDIU_NEG_(uint64 instruction);
-    std::string ADDIU_R1_SP_(uint64 instruction);
-    std::string ADDIU_R2_(uint64 instruction);
-    std::string ADDIU_RS5_(uint64 instruction);
-    std::string ADDIUPC_32_(uint64 instruction);
-    std::string ADDIUPC_48_(uint64 instruction);
-    std::string ADDQ_PH(uint64 instruction);
-    std::string ADDQ_S_PH(uint64 instruction);
-    std::string ADDQ_S_W(uint64 instruction);
-    std::string ADDQH_PH(uint64 instruction);
-    std::string ADDQH_R_PH(uint64 instruction);
-    std::string ADDQH_R_W(uint64 instruction);
-    std::string ADDQH_W(uint64 instruction);
-    std::string ADDSC(uint64 instruction);
-    std::string ADDU_16_(uint64 instruction);
-    std::string ADDU_32_(uint64 instruction);
-    std::string ADDU_4X4_(uint64 instruction);
-    std::string ADDU_PH(uint64 instruction);
-    std::string ADDU_QB(uint64 instruction);
-    std::string ADDU_S_PH(uint64 instruction);
-    std::string ADDU_S_QB(uint64 instruction);
-    std::string ADDUH_QB(uint64 instruction);
-    std::string ADDUH_R_QB(uint64 instruction);
-    std::string ADDWC(uint64 instruction);
-    std::string ALUIPC(uint64 instruction);
-    std::string AND_16_(uint64 instruction);
-    std::string AND_32_(uint64 instruction);
-    std::string ANDI_16_(uint64 instruction);
-    std::string ANDI_32_(uint64 instruction);
-    std::string APPEND(uint64 instruction);
-    std::string ASET(uint64 instruction);
-    std::string BALC_16_(uint64 instruction);
-    std::string BALC_32_(uint64 instruction);
-    std::string BALRSC(uint64 instruction);
-    std::string BBEQZC(uint64 instruction);
-    std::string BBNEZC(uint64 instruction);
-    std::string BC_16_(uint64 instruction);
-    std::string BC_32_(uint64 instruction);
-    std::string BC1EQZC(uint64 instruction);
-    std::string BC1NEZC(uint64 instruction);
-    std::string BC2EQZC(uint64 instruction);
-    std::string BC2NEZC(uint64 instruction);
-    std::string BEQC_16_(uint64 instruction);
-    std::string BEQC_32_(uint64 instruction);
-    std::string BEQIC(uint64 instruction);
-    std::string BEQZC_16_(uint64 instruction);
-    std::string BGEC(uint64 instruction);
-    std::string BGEIC(uint64 instruction);
-    std::string BGEIUC(uint64 instruction);
-    std::string BGEUC(uint64 instruction);
-    std::string BLTC(uint64 instruction);
-    std::string BLTIC(uint64 instruction);
-    std::string BLTIUC(uint64 instruction);
-    std::string BLTUC(uint64 instruction);
-    std::string BNEC_16_(uint64 instruction);
-    std::string BNEC_32_(uint64 instruction);
-    std::string BNEIC(uint64 instruction);
-    std::string BNEZC_16_(uint64 instruction);
-    std::string BPOSGE32C(uint64 instruction);
-    std::string BREAK_16_(uint64 instruction);
-    std::string BREAK_32_(uint64 instruction);
-    std::string BRSC(uint64 instruction);
-    std::string CACHE(uint64 instruction);
-    std::string CACHEE(uint64 instruction);
-    std::string CEIL_L_D(uint64 instruction);
-    std::string CEIL_L_S(uint64 instruction);
-    std::string CEIL_W_D(uint64 instruction);
-    std::string CEIL_W_S(uint64 instruction);
-    std::string CFC1(uint64 instruction);
-    std::string CFC2(uint64 instruction);
-    std::string CLASS_D(uint64 instruction);
-    std::string CLASS_S(uint64 instruction);
-    std::string CLO(uint64 instruction);
-    std::string CLZ(uint64 instruction);
-    std::string CMP_AF_D(uint64 instruction);
-    std::string CMP_AF_S(uint64 instruction);
-    std::string CMP_EQ_D(uint64 instruction);
-    std::string CMP_EQ_PH(uint64 instruction);
-    std::string CMP_EQ_S(uint64 instruction);
-    std::string CMP_LE_D(uint64 instruction);
-    std::string CMP_LE_PH(uint64 instruction);
-    std::string CMP_LE_S(uint64 instruction);
-    std::string CMP_LT_D(uint64 instruction);
-    std::string CMP_LT_PH(uint64 instruction);
-    std::string CMP_LT_S(uint64 instruction);
-    std::string CMP_NE_D(uint64 instruction);
-    std::string CMP_NE_S(uint64 instruction);
-    std::string CMP_OR_D(uint64 instruction);
-    std::string CMP_OR_S(uint64 instruction);
-    std::string CMP_SAF_D(uint64 instruction);
-    std::string CMP_SAF_S(uint64 instruction);
-    std::string CMP_SEQ_D(uint64 instruction);
-    std::string CMP_SEQ_S(uint64 instruction);
-    std::string CMP_SLE_D(uint64 instruction);
-    std::string CMP_SLE_S(uint64 instruction);
-    std::string CMP_SLT_D(uint64 instruction);
-    std::string CMP_SLT_S(uint64 instruction);
-    std::string CMP_SNE_D(uint64 instruction);
-    std::string CMP_SNE_S(uint64 instruction);
-    std::string CMP_SOR_D(uint64 instruction);
-    std::string CMP_SOR_S(uint64 instruction);
-    std::string CMP_SUEQ_D(uint64 instruction);
-    std::string CMP_SUEQ_S(uint64 instruction);
-    std::string CMP_SULE_D(uint64 instruction);
-    std::string CMP_SULE_S(uint64 instruction);
-    std::string CMP_SULT_D(uint64 instruction);
-    std::string CMP_SULT_S(uint64 instruction);
-    std::string CMP_SUN_D(uint64 instruction);
-    std::string CMP_SUN_S(uint64 instruction);
-    std::string CMP_SUNE_D(uint64 instruction);
-    std::string CMP_SUNE_S(uint64 instruction);
-    std::string CMP_UEQ_D(uint64 instruction);
-    std::string CMP_UEQ_S(uint64 instruction);
-    std::string CMP_ULE_D(uint64 instruction);
-    std::string CMP_ULE_S(uint64 instruction);
-    std::string CMP_ULT_D(uint64 instruction);
-    std::string CMP_ULT_S(uint64 instruction);
-    std::string CMP_UN_D(uint64 instruction);
-    std::string CMP_UN_S(uint64 instruction);
-    std::string CMP_UNE_D(uint64 instruction);
-    std::string CMP_UNE_S(uint64 instruction);
-    std::string CMPGDU_EQ_QB(uint64 instruction);
-    std::string CMPGDU_LE_QB(uint64 instruction);
-    std::string CMPGDU_LT_QB(uint64 instruction);
-    std::string CMPGU_EQ_QB(uint64 instruction);
-    std::string CMPGU_LE_QB(uint64 instruction);
-    std::string CMPGU_LT_QB(uint64 instruction);
-    std::string CMPU_EQ_QB(uint64 instruction);
-    std::string CMPU_LE_QB(uint64 instruction);
-    std::string CMPU_LT_QB(uint64 instruction);
-    std::string COP2_1(uint64 instruction);
-    std::string CTC1(uint64 instruction);
-    std::string CTC2(uint64 instruction);
-    std::string CVT_D_L(uint64 instruction);
-    std::string CVT_D_S(uint64 instruction);
-    std::string CVT_D_W(uint64 instruction);
-    std::string CVT_L_D(uint64 instruction);
-    std::string CVT_L_S(uint64 instruction);
-    std::string CVT_S_D(uint64 instruction);
-    std::string CVT_S_L(uint64 instruction);
-    std::string CVT_S_PL(uint64 instruction);
-    std::string CVT_S_PU(uint64 instruction);
-    std::string CVT_S_W(uint64 instruction);
-    std::string CVT_W_D(uint64 instruction);
-    std::string CVT_W_S(uint64 instruction);
-    std::string DADDIU_48_(uint64 instruction);
-    std::string DADDIU_NEG_(uint64 instruction);
-    std::string DADDIU_U12_(uint64 instruction);
-    std::string DADD(uint64 instruction);
-    std::string DADDU(uint64 instruction);
-    std::string DCLO(uint64 instruction);
-    std::string DCLZ(uint64 instruction);
-    std::string DDIV(uint64 instruction);
-    std::string DDIVU(uint64 instruction);
-    std::string DERET(uint64 instruction);
-    std::string DEXTM(uint64 instruction);
-    std::string DEXT(uint64 instruction);
-    std::string DEXTU(uint64 instruction);
-    std::string DINSM(uint64 instruction);
-    std::string DINS(uint64 instruction);
-    std::string DINSU(uint64 instruction);
-    std::string DI(uint64 instruction);
-    std::string DIV(uint64 instruction);
-    std::string DIV_D(uint64 instruction);
-    std::string DIV_S(uint64 instruction);
-    std::string DIVU(uint64 instruction);
-    std::string DLSA(uint64 instruction);
-    std::string DLUI_48_(uint64 instruction);
-    std::string DMFC0(uint64 instruction);
-    std::string DMFC1(uint64 instruction);
-    std::string DMFC2(uint64 instruction);
-    std::string DMFGC0(uint64 instruction);
-    std::string DMOD(uint64 instruction);
-    std::string DMODU(uint64 instruction);
-    std::string DMTC0(uint64 instruction);
-    std::string DMTC1(uint64 instruction);
-    std::string DMTC2(uint64 instruction);
-    std::string DMTGC0(uint64 instruction);
-    std::string DMT(uint64 instruction);
-    std::string DMUH(uint64 instruction);
-    std::string DMUHU(uint64 instruction);
-    std::string DMUL(uint64 instruction);
-    std::string DMULU(uint64 instruction);
-    std::string DPAQ_S_W_PH(uint64 instruction);
-    std::string DPAQ_SA_L_W(uint64 instruction);
-    std::string DPAQX_S_W_PH(uint64 instruction);
-    std::string DPAQX_SA_W_PH(uint64 instruction);
-    std::string DPAU_H_QBL(uint64 instruction);
-    std::string DPAU_H_QBR(uint64 instruction);
-    std::string DPA_W_PH(uint64 instruction);
-    std::string DPAX_W_PH(uint64 instruction);
-    std::string DPS_W_PH(uint64 instruction);
-    std::string DPSQ_SA_L_W(uint64 instruction);
-    std::string DPSQ_S_W_PH(uint64 instruction);
-    std::string DPSQX_SA_W_PH(uint64 instruction);
-    std::string DPSQX_S_W_PH(uint64 instruction);
-    std::string DPSU_H_QBL(uint64 instruction);
-    std::string DPSU_H_QBR(uint64 instruction);
-    std::string DPSX_W_PH(uint64 instruction);
-    std::string DROTR(uint64 instruction);
-    std::string DROTR32(uint64 instruction);
-    std::string DROTRV(uint64 instruction);
-    std::string DROTX(uint64 instruction);
-    std::string DSLL(uint64 instruction);
-    std::string DSLL32(uint64 instruction);
-    std::string DSLLV(uint64 instruction);
-    std::string DSRA(uint64 instruction);
-    std::string DSRA32(uint64 instruction);
-    std::string DSRAV(uint64 instruction);
-    std::string DSRL32(uint64 instruction);
-    std::string DSRL(uint64 instruction);
-    std::string DSRLV(uint64 instruction);
-    std::string DSUB(uint64 instruction);
-    std::string DSUBU(uint64 instruction);
-    std::string DVP(uint64 instruction);
-    std::string DVPE(uint64 instruction);
-    std::string EHB(uint64 instruction);
-    std::string EI(uint64 instruction);
-    std::string EMT(uint64 instruction);
-    std::string ERET(uint64 instruction);
-    std::string ERETNC(uint64 instruction);
-    std::string EVP(uint64 instruction);
-    std::string EVPE(uint64 instruction);
-    std::string EXT(uint64 instruction);
-    std::string EXTD(uint64 instruction);
-    std::string EXTD32(uint64 instruction);
-    std::string EXTP(uint64 instruction);
-    std::string EXTPDP(uint64 instruction);
-    std::string EXTPDPV(uint64 instruction);
-    std::string EXTPV(uint64 instruction);
-    std::string EXTR_RS_W(uint64 instruction);
-    std::string EXTR_R_W(uint64 instruction);
-    std::string EXTR_S_H(uint64 instruction);
-    std::string EXTR_W(uint64 instruction);
-    std::string EXTRV_R_W(uint64 instruction);
-    std::string EXTRV_RS_W(uint64 instruction);
-    std::string EXTRV_S_H(uint64 instruction);
-    std::string EXTRV_W(uint64 instruction);
-    std::string EXTW(uint64 instruction);
-    std::string FLOOR_L_D(uint64 instruction);
-    std::string FLOOR_L_S(uint64 instruction);
-    std::string FLOOR_W_D(uint64 instruction);
-    std::string FLOOR_W_S(uint64 instruction);
-    std::string FORK(uint64 instruction);
-    std::string HYPCALL(uint64 instruction);
-    std::string HYPCALL_16_(uint64 instruction);
-    std::string INS(uint64 instruction);
-    std::string INSV(uint64 instruction);
-    std::string IRET(uint64 instruction);
-    std::string JALRC_16_(uint64 instruction);
-    std::string JALRC_32_(uint64 instruction);
-    std::string JALRC_HB(uint64 instruction);
-    std::string JRC(uint64 instruction);
-    std::string LB_16_(uint64 instruction);
-    std::string LB_GP_(uint64 instruction);
-    std::string LB_S9_(uint64 instruction);
-    std::string LB_U12_(uint64 instruction);
-    std::string LBE(uint64 instruction);
-    std::string LBU_16_(uint64 instruction);
-    std::string LBU_GP_(uint64 instruction);
-    std::string LBU_S9_(uint64 instruction);
-    std::string LBU_U12_(uint64 instruction);
-    std::string LBUE(uint64 instruction);
-    std::string LBUX(uint64 instruction);
-    std::string LBX(uint64 instruction);
-    std::string LD_GP_(uint64 instruction);
-    std::string LD_S9_(uint64 instruction);
-    std::string LD_U12_(uint64 instruction);
-    std::string LDC1_GP_(uint64 instruction);
-    std::string LDC1_S9_(uint64 instruction);
-    std::string LDC1_U12_(uint64 instruction);
-    std::string LDC1X(uint64 instruction);
-    std::string LDC1XS(uint64 instruction);
-    std::string LDC2(uint64 instruction);
-    std::string LDM(uint64 instruction);
-    std::string LDPC_48_(uint64 instruction);
-    std::string LDX(uint64 instruction);
-    std::string LDXS(uint64 instruction);
-    std::string LH_16_(uint64 instruction);
-    std::string LH_GP_(uint64 instruction);
-    std::string LH_S9_(uint64 instruction);
-    std::string LH_U12_(uint64 instruction);
-    std::string LHE(uint64 instruction);
-    std::string LHU_16_(uint64 instruction);
-    std::string LHU_GP_(uint64 instruction);
-    std::string LHU_S9_(uint64 instruction);
-    std::string LHU_U12_(uint64 instruction);
-    std::string LHUE(uint64 instruction);
-    std::string LHUX(uint64 instruction);
-    std::string LHUXS(uint64 instruction);
-    std::string LHX(uint64 instruction);
-    std::string LHXS(uint64 instruction);
-    std::string LI_16_(uint64 instruction);
-    std::string LI_48_(uint64 instruction);
-    std::string LL(uint64 instruction);
-    std::string LLD(uint64 instruction);
-    std::string LLDP(uint64 instruction);
-    std::string LLE(uint64 instruction);
-    std::string LLWP(uint64 instruction);
-    std::string LLWPE(uint64 instruction);
-    std::string LSA(uint64 instruction);
-    std::string LUI(uint64 instruction);
-    std::string LW_16_(uint64 instruction);
-    std::string LW_4X4_(uint64 instruction);
-    std::string LWC1_GP_(uint64 instruction);
-    std::string LWC1_S9_(uint64 instruction);
-    std::string LWC1_U12_(uint64 instruction);
-    std::string LWC1X(uint64 instruction);
-    std::string LWC1XS(uint64 instruction);
-    std::string LWC2(uint64 instruction);
-    std::string LWE(uint64 instruction);
-    std::string LW_GP_(uint64 instruction);
-    std::string LW_GP16_(uint64 instruction);
-    std::string LWM(uint64 instruction);
-    std::string LWPC_48_(uint64 instruction);
-    std::string LW_S9_(uint64 instruction);
-    std::string LW_SP_(uint64 instruction);
-    std::string LW_U12_(uint64 instruction);
-    std::string LWU_GP_(uint64 instruction);
-    std::string LWU_S9_(uint64 instruction);
-    std::string LWU_U12_(uint64 instruction);
-    std::string LWUX(uint64 instruction);
-    std::string LWUXS(uint64 instruction);
-    std::string LWX(uint64 instruction);
-    std::string LWXS_16_(uint64 instruction);
-    std::string LWXS_32_(uint64 instruction);
-    std::string MADD_DSP_(uint64 instruction);
-    std::string MADDF_D(uint64 instruction);
-    std::string MADDF_S(uint64 instruction);
-    std::string MADDU_DSP_(uint64 instruction);
-    std::string MAQ_S_W_PHL(uint64 instruction);
-    std::string MAQ_S_W_PHR(uint64 instruction);
-    std::string MAQ_SA_W_PHL(uint64 instruction);
-    std::string MAQ_SA_W_PHR(uint64 instruction);
-    std::string MAX_D(uint64 instruction);
-    std::string MAX_S(uint64 instruction);
-    std::string MAXA_D(uint64 instruction);
-    std::string MAXA_S(uint64 instruction);
-    std::string MFC0(uint64 instruction);
-    std::string MFC1(uint64 instruction);
-    std::string MFC2(uint64 instruction);
-    std::string MFGC0(uint64 instruction);
-    std::string MFHC0(uint64 instruction);
-    std::string MFHC1(uint64 instruction);
-    std::string MFHC2(uint64 instruction);
-    std::string MFHGC0(uint64 instruction);
-    std::string MFHI_DSP_(uint64 instruction);
-    std::string MFHTR(uint64 instruction);
-    std::string MFLO_DSP_(uint64 instruction);
-    std::string MFTR(uint64 instruction);
-    std::string MIN_D(uint64 instruction);
-    std::string MIN_S(uint64 instruction);
-    std::string MINA_D(uint64 instruction);
-    std::string MINA_S(uint64 instruction);
-    std::string MOD(uint64 instruction);
-    std::string MODSUB(uint64 instruction);
-    std::string MODU(uint64 instruction);
-    std::string MOV_D(uint64 instruction);
-    std::string MOV_S(uint64 instruction);
-    std::string MOVE_BALC(uint64 instruction);
-    std::string MOVEP(uint64 instruction);
-    std::string MOVEP_REV_(uint64 instruction);
-    std::string MOVE(uint64 instruction);
-    std::string MOVN(uint64 instruction);
-    std::string MOVZ(uint64 instruction);
-    std::string MSUB_DSP_(uint64 instruction);
-    std::string MSUBF_D(uint64 instruction);
-    std::string MSUBF_S(uint64 instruction);
-    std::string MSUBU_DSP_(uint64 instruction);
-    std::string MTC0(uint64 instruction);
-    std::string MTC1(uint64 instruction);
-    std::string MTC2(uint64 instruction);
-    std::string MTGC0(uint64 instruction);
-    std::string MTHC0(uint64 instruction);
-    std::string MTHC1(uint64 instruction);
-    std::string MTHC2(uint64 instruction);
-    std::string MTHGC0(uint64 instruction);
-    std::string MTHI_DSP_(uint64 instruction);
-    std::string MTHLIP(uint64 instruction);
-    std::string MTHTR(uint64 instruction);
-    std::string MTLO_DSP_(uint64 instruction);
-    std::string MTTR(uint64 instruction);
-    std::string MUH(uint64 instruction);
-    std::string MUHU(uint64 instruction);
-    std::string MUL_32_(uint64 instruction);
-    std::string MUL_4X4_(uint64 instruction);
-    std::string MUL_D(uint64 instruction);
-    std::string MUL_PH(uint64 instruction);
-    std::string MUL_S(uint64 instruction);
-    std::string MUL_S_PH(uint64 instruction);
-    std::string MULEQ_S_W_PHL(uint64 instruction);
-    std::string MULEQ_S_W_PHR(uint64 instruction);
-    std::string MULEU_S_PH_QBL(uint64 instruction);
-    std::string MULEU_S_PH_QBR(uint64 instruction);
-    std::string MULQ_RS_PH(uint64 instruction);
-    std::string MULQ_RS_W(uint64 instruction);
-    std::string MULQ_S_PH(uint64 instruction);
-    std::string MULQ_S_W(uint64 instruction);
-    std::string MULSA_W_PH(uint64 instruction);
-    std::string MULSAQ_S_W_PH(uint64 instruction);
-    std::string MULT_DSP_(uint64 instruction);
-    std::string MULTU_DSP_(uint64 instruction);
-    std::string MULU(uint64 instruction);
-    std::string NEG_D(uint64 instruction);
-    std::string NEG_S(uint64 instruction);
-    std::string NOP_16_(uint64 instruction);
-    std::string NOP_32_(uint64 instruction);
-    std::string NOR(uint64 instruction);
-    std::string NOT_16_(uint64 instruction);
-    std::string OR_16_(uint64 instruction);
-    std::string OR_32_(uint64 instruction);
-    std::string ORI(uint64 instruction);
-    std::string PACKRL_PH(uint64 instruction);
-    std::string PAUSE(uint64 instruction);
-    std::string PICK_PH(uint64 instruction);
-    std::string PICK_QB(uint64 instruction);
-    std::string PRECEQ_W_PHL(uint64 instruction);
-    std::string PRECEQ_W_PHR(uint64 instruction);
-    std::string PRECEQU_PH_QBL(uint64 instruction);
-    std::string PRECEQU_PH_QBLA(uint64 instruction);
-    std::string PRECEQU_PH_QBR(uint64 instruction);
-    std::string PRECEQU_PH_QBRA(uint64 instruction);
-    std::string PRECEU_PH_QBL(uint64 instruction);
-    std::string PRECEU_PH_QBLA(uint64 instruction);
-    std::string PRECEU_PH_QBR(uint64 instruction);
-    std::string PRECEU_PH_QBRA(uint64 instruction);
-    std::string PRECR_QB_PH(uint64 instruction);
-    std::string PRECR_SRA_PH_W(uint64 instruction);
-    std::string PRECR_SRA_R_PH_W(uint64 instruction);
-    std::string PRECRQ_PH_W(uint64 instruction);
-    std::string PRECRQ_QB_PH(uint64 instruction);
-    std::string PRECRQ_RS_PH_W(uint64 instruction);
-    std::string PRECRQU_S_QB_PH(uint64 instruction);
-    std::string PREF_S9_(uint64 instruction);
-    std::string PREF_U12_(uint64 instruction);
-    std::string PREFE(uint64 instruction);
-    std::string PREPEND(uint64 instruction);
-    std::string RADDU_W_QB(uint64 instruction);
-    std::string RDDSP(uint64 instruction);
-    std::string RDHWR(uint64 instruction);
-    std::string RDPGPR(uint64 instruction);
-    std::string RECIP_D(uint64 instruction);
-    std::string RECIP_S(uint64 instruction);
-    std::string REPL_PH(uint64 instruction);
-    std::string REPL_QB(uint64 instruction);
-    std::string REPLV_PH(uint64 instruction);
-    std::string REPLV_QB(uint64 instruction);
-    std::string RESTORE_32_(uint64 instruction);
-    std::string RESTORE_JRC_16_(uint64 instruction);
-    std::string RESTORE_JRC_32_(uint64 instruction);
-    std::string RESTOREF(uint64 instruction);
-    std::string RINT_D(uint64 instruction);
-    std::string RINT_S(uint64 instruction);
-    std::string ROTR(uint64 instruction);
-    std::string ROTRV(uint64 instruction);
-    std::string ROTX(uint64 instruction);
-    std::string ROUND_L_D(uint64 instruction);
-    std::string ROUND_L_S(uint64 instruction);
-    std::string ROUND_W_D(uint64 instruction);
-    std::string ROUND_W_S(uint64 instruction);
-    std::string RSQRT_D(uint64 instruction);
-    std::string RSQRT_S(uint64 instruction);
-    std::string SAVE_16_(uint64 instruction);
-    std::string SAVE_32_(uint64 instruction);
-    std::string SAVEF(uint64 instruction);
-    std::string SB_16_(uint64 instruction);
-    std::string SB_GP_(uint64 instruction);
-    std::string SB_S9_(uint64 instruction);
-    std::string SB_U12_(uint64 instruction);
-    std::string SBE(uint64 instruction);
-    std::string SBX(uint64 instruction);
-    std::string SC(uint64 instruction);
-    std::string SCD(uint64 instruction);
-    std::string SCDP(uint64 instruction);
-    std::string SCE(uint64 instruction);
-    std::string SCWP(uint64 instruction);
-    std::string SCWPE(uint64 instruction);
-    std::string SD_GP_(uint64 instruction);
-    std::string SD_S9_(uint64 instruction);
-    std::string SD_U12_(uint64 instruction);
-    std::string SDBBP_16_(uint64 instruction);
-    std::string SDBBP_32_(uint64 instruction);
-    std::string SDC1_GP_(uint64 instruction);
-    std::string SDC1_S9_(uint64 instruction);
-    std::string SDC1_U12_(uint64 instruction);
-    std::string SDC1X(uint64 instruction);
-    std::string SDC1XS(uint64 instruction);
-    std::string SDC2(uint64 instruction);
-    std::string SDM(uint64 instruction);
-    std::string SDPC_48_(uint64 instruction);
-    std::string SDX(uint64 instruction);
-    std::string SDXS(uint64 instruction);
-    std::string SEB(uint64 instruction);
-    std::string SEH(uint64 instruction);
-    std::string SEL_D(uint64 instruction);
-    std::string SEL_S(uint64 instruction);
-    std::string SELEQZ_D(uint64 instruction);
-    std::string SELEQZ_S(uint64 instruction);
-    std::string SELNEZ_D(uint64 instruction);
-    std::string SELNEZ_S(uint64 instruction);
-    std::string SEQI(uint64 instruction);
-    std::string SH_16_(uint64 instruction);
-    std::string SH_GP_(uint64 instruction);
-    std::string SH_S9_(uint64 instruction);
-    std::string SH_U12_(uint64 instruction);
-    std::string SHE(uint64 instruction);
-    std::string SHILO(uint64 instruction);
-    std::string SHILOV(uint64 instruction);
-    std::string SHLL_PH(uint64 instruction);
-    std::string SHLL_QB(uint64 instruction);
-    std::string SHLL_S_PH(uint64 instruction);
-    std::string SHLL_S_W(uint64 instruction);
-    std::string SHLLV_PH(uint64 instruction);
-    std::string SHLLV_QB(uint64 instruction);
-    std::string SHLLV_S_PH(uint64 instruction);
-    std::string SHLLV_S_W(uint64 instruction);
-    std::string SHRA_PH(uint64 instruction);
-    std::string SHRA_QB(uint64 instruction);
-    std::string SHRA_R_PH(uint64 instruction);
-    std::string SHRA_R_QB(uint64 instruction);
-    std::string SHRA_R_W(uint64 instruction);
-    std::string SHRAV_PH(uint64 instruction);
-    std::string SHRAV_QB(uint64 instruction);
-    std::string SHRAV_R_PH(uint64 instruction);
-    std::string SHRAV_R_QB(uint64 instruction);
-    std::string SHRAV_R_W(uint64 instruction);
-    std::string SHRL_PH(uint64 instruction);
-    std::string SHRL_QB(uint64 instruction);
-    std::string SHRLV_PH(uint64 instruction);
-    std::string SHRLV_QB(uint64 instruction);
-    std::string SHX(uint64 instruction);
-    std::string SHXS(uint64 instruction);
-    std::string SIGRIE(uint64 instruction);
-    std::string SLL_16_(uint64 instruction);
-    std::string SLL_32_(uint64 instruction);
-    std::string SLLV(uint64 instruction);
-    std::string SLT(uint64 instruction);
-    std::string SLTI(uint64 instruction);
-    std::string SLTIU(uint64 instruction);
-    std::string SLTU(uint64 instruction);
-    std::string SOV(uint64 instruction);
-    std::string SPECIAL2(uint64 instruction);
-    std::string SQRT_D(uint64 instruction);
-    std::string SQRT_S(uint64 instruction);
-    std::string SRA(uint64 instruction);
-    std::string SRAV(uint64 instruction);
-    std::string SRL_16_(uint64 instruction);
-    std::string SRL_32_(uint64 instruction);
-    std::string SRLV(uint64 instruction);
-    std::string SUB(uint64 instruction);
-    std::string SUB_D(uint64 instruction);
-    std::string SUB_S(uint64 instruction);
-    std::string SUBQ_PH(uint64 instruction);
-    std::string SUBQ_S_PH(uint64 instruction);
-    std::string SUBQ_S_W(uint64 instruction);
-    std::string SUBQH_PH(uint64 instruction);
-    std::string SUBQH_R_PH(uint64 instruction);
-    std::string SUBQH_R_W(uint64 instruction);
-    std::string SUBQH_W(uint64 instruction);
-    std::string SUBU_16_(uint64 instruction);
-    std::string SUBU_32_(uint64 instruction);
-    std::string SUBU_PH(uint64 instruction);
-    std::string SUBU_QB(uint64 instruction);
-    std::string SUBU_S_PH(uint64 instruction);
-    std::string SUBU_S_QB(uint64 instruction);
-    std::string SUBUH_QB(uint64 instruction);
-    std::string SUBUH_R_QB(uint64 instruction);
-    std::string SW_16_(uint64 instruction);
-    std::string SW_4X4_(uint64 instruction);
-    std::string SW_GP16_(uint64 instruction);
-    std::string SW_GP_(uint64 instruction);
-    std::string SW_S9_(uint64 instruction);
-    std::string SW_SP_(uint64 instruction);
-    std::string SW_U12_(uint64 instruction);
-    std::string SWC1_GP_(uint64 instruction);
-    std::string SWC1_S9_(uint64 instruction);
-    std::string SWC1_U12_(uint64 instruction);
-    std::string SWC1X(uint64 instruction);
-    std::string SWC1XS(uint64 instruction);
-    std::string SWC2(uint64 instruction);
-    std::string SWE(uint64 instruction);
-    std::string SWM(uint64 instruction);
-    std::string SWPC_48_(uint64 instruction);
-    std::string SWX(uint64 instruction);
-    std::string SWXS(uint64 instruction);
-    std::string SYNC(uint64 instruction);
-    std::string SYNCI(uint64 instruction);
-    std::string SYNCIE(uint64 instruction);
-    std::string SYSCALL_16_(uint64 instruction);
-    std::string SYSCALL_32_(uint64 instruction);
-    std::string TEQ(uint64 instruction);
-    std::string TLBGINV(uint64 instruction);
-    std::string TLBGINVF(uint64 instruction);
-    std::string TLBGP(uint64 instruction);
-    std::string TLBGR(uint64 instruction);
-    std::string TLBGWI(uint64 instruction);
-    std::string TLBGWR(uint64 instruction);
-    std::string TLBINV(uint64 instruction);
-    std::string TLBINVF(uint64 instruction);
-    std::string TLBP(uint64 instruction);
-    std::string TLBR(uint64 instruction);
-    std::string TLBWI(uint64 instruction);
-    std::string TLBWR(uint64 instruction);
-    std::string TNE(uint64 instruction);
-    std::string TRUNC_L_D(uint64 instruction);
-    std::string TRUNC_L_S(uint64 instruction);
-    std::string TRUNC_W_D(uint64 instruction);
-    std::string TRUNC_W_S(uint64 instruction);
-    std::string UALDM(uint64 instruction);
-    std::string UALH(uint64 instruction);
-    std::string UALWM(uint64 instruction);
-    std::string UASDM(uint64 instruction);
-    std::string UASH(uint64 instruction);
-    std::string UASWM(uint64 instruction);
-    std::string UDI(uint64 instruction);
-    std::string WAIT(uint64 instruction);
-    std::string WRDSP(uint64 instruction);
-    std::string WRPGPR(uint64 instruction);
-    std::string XOR_16_(uint64 instruction);
-    std::string XOR_32_(uint64 instruction);
-    std::string XORI(uint64 instruction);
-    std::string YIELD(uint64 instruction);
+    std::string ABS_D(uint64 instruction, img_address m_pc);
+    std::string ABS_S(uint64 instruction, img_address m_pc);
+    std::string ABSQ_S_PH(uint64 instruction, img_address m_pc);
+    std::string ABSQ_S_QB(uint64 instruction, img_address m_pc);
+    std::string ABSQ_S_W(uint64 instruction, img_address m_pc);
+    std::string ACLR(uint64 instruction, img_address m_pc);
+    std::string ADD(uint64 instruction, img_address m_pc);
+    std::string ADD_D(uint64 instruction, img_address m_pc);
+    std::string ADD_S(uint64 instruction, img_address m_pc);
+    std::string ADDIU_32_(uint64 instruction, img_address m_pc);
+    std::string ADDIU_48_(uint64 instruction, img_address m_pc);
+    std::string ADDIU_GP48_(uint64 instruction, img_address m_pc);
+    std::string ADDIU_GP_B_(uint64 instruction, img_address m_pc);
+    std::string ADDIU_GP_W_(uint64 instruction, img_address m_pc);
+    std::string ADDIU_NEG_(uint64 instruction, img_address m_pc);
+    std::string ADDIU_R1_SP_(uint64 instruction, img_address m_pc);
+    std::string ADDIU_R2_(uint64 instruction, img_address m_pc);
+    std::string ADDIU_RS5_(uint64 instruction, img_address m_pc);
+    std::string ADDIUPC_32_(uint64 instruction, img_address m_pc);
+    std::string ADDIUPC_48_(uint64 instruction, img_address m_pc);
+    std::string ADDQ_PH(uint64 instruction, img_address m_pc);
+    std::string ADDQ_S_PH(uint64 instruction, img_address m_pc);
+    std::string ADDQ_S_W(uint64 instruction, img_address m_pc);
+    std::string ADDQH_PH(uint64 instruction, img_address m_pc);
+    std::string ADDQH_R_PH(uint64 instruction, img_address m_pc);
+    std::string ADDQH_R_W(uint64 instruction, img_address m_pc);
+    std::string ADDQH_W(uint64 instruction, img_address m_pc);
+    std::string ADDSC(uint64 instruction, img_address m_pc);
+    std::string ADDU_16_(uint64 instruction, img_address m_pc);
+    std::string ADDU_32_(uint64 instruction, img_address m_pc);
+    std::string ADDU_4X4_(uint64 instruction, img_address m_pc);
+    std::string ADDU_PH(uint64 instruction, img_address m_pc);
+    std::string ADDU_QB(uint64 instruction, img_address m_pc);
+    std::string ADDU_S_PH(uint64 instruction, img_address m_pc);
+    std::string ADDU_S_QB(uint64 instruction, img_address m_pc);
+    std::string ADDUH_QB(uint64 instruction, img_address m_pc);
+    std::string ADDUH_R_QB(uint64 instruction, img_address m_pc);
+    std::string ADDWC(uint64 instruction, img_address m_pc);
+    std::string ALUIPC(uint64 instruction, img_address m_pc);
+    std::string AND_16_(uint64 instruction, img_address m_pc);
+    std::string AND_32_(uint64 instruction, img_address m_pc);
+    std::string ANDI_16_(uint64 instruction, img_address m_pc);
+    std::string ANDI_32_(uint64 instruction, img_address m_pc);
+    std::string APPEND(uint64 instruction, img_address m_pc);
+    std::string ASET(uint64 instruction, img_address m_pc);
+    std::string BALC_16_(uint64 instruction, img_address m_pc);
+    std::string BALC_32_(uint64 instruction, img_address m_pc);
+    std::string BALRSC(uint64 instruction, img_address m_pc);
+    std::string BBEQZC(uint64 instruction, img_address m_pc);
+    std::string BBNEZC(uint64 instruction, img_address m_pc);
+    std::string BC_16_(uint64 instruction, img_address m_pc);
+    std::string BC_32_(uint64 instruction, img_address m_pc);
+    std::string BC1EQZC(uint64 instruction, img_address m_pc);
+    std::string BC1NEZC(uint64 instruction, img_address m_pc);
+    std::string BC2EQZC(uint64 instruction, img_address m_pc);
+    std::string BC2NEZC(uint64 instruction, img_address m_pc);
+    std::string BEQC_16_(uint64 instruction, img_address m_pc);
+    std::string BEQC_32_(uint64 instruction, img_address m_pc);
+    std::string BEQIC(uint64 instruction, img_address m_pc);
+    std::string BEQZC_16_(uint64 instruction, img_address m_pc);
+    std::string BGEC(uint64 instruction, img_address m_pc);
+    std::string BGEIC(uint64 instruction, img_address m_pc);
+    std::string BGEIUC(uint64 instruction, img_address m_pc);
+    std::string BGEUC(uint64 instruction, img_address m_pc);
+    std::string BLTC(uint64 instruction, img_address m_pc);
+    std::string BLTIC(uint64 instruction, img_address m_pc);
+    std::string BLTIUC(uint64 instruction, img_address m_pc);
+    std::string BLTUC(uint64 instruction, img_address m_pc);
+    std::string BNEC_16_(uint64 instruction, img_address m_pc);
+    std::string BNEC_32_(uint64 instruction, img_address m_pc);
+    std::string BNEIC(uint64 instruction, img_address m_pc);
+    std::string BNEZC_16_(uint64 instruction, img_address m_pc);
+    std::string BPOSGE32C(uint64 instruction, img_address m_pc);
+    std::string BREAK_16_(uint64 instruction, img_address m_pc);
+    std::string BREAK_32_(uint64 instruction, img_address m_pc);
+    std::string BRSC(uint64 instruction, img_address m_pc);
+    std::string CACHE(uint64 instruction, img_address m_pc);
+    std::string CACHEE(uint64 instruction, img_address m_pc);
+    std::string CEIL_L_D(uint64 instruction, img_address m_pc);
+    std::string CEIL_L_S(uint64 instruction, img_address m_pc);
+    std::string CEIL_W_D(uint64 instruction, img_address m_pc);
+    std::string CEIL_W_S(uint64 instruction, img_address m_pc);
+    std::string CFC1(uint64 instruction, img_address m_pc);
+    std::string CFC2(uint64 instruction, img_address m_pc);
+    std::string CLASS_D(uint64 instruction, img_address m_pc);
+    std::string CLASS_S(uint64 instruction, img_address m_pc);
+    std::string CLO(uint64 instruction, img_address m_pc);
+    std::string CLZ(uint64 instruction, img_address m_pc);
+    std::string CMP_AF_D(uint64 instruction, img_address m_pc);
+    std::string CMP_AF_S(uint64 instruction, img_address m_pc);
+    std::string CMP_EQ_D(uint64 instruction, img_address m_pc);
+    std::string CMP_EQ_PH(uint64 instruction, img_address m_pc);
+    std::string CMP_EQ_S(uint64 instruction, img_address m_pc);
+    std::string CMP_LE_D(uint64 instruction, img_address m_pc);
+    std::string CMP_LE_PH(uint64 instruction, img_address m_pc);
+    std::string CMP_LE_S(uint64 instruction, img_address m_pc);
+    std::string CMP_LT_D(uint64 instruction, img_address m_pc);
+    std::string CMP_LT_PH(uint64 instruction, img_address m_pc);
+    std::string CMP_LT_S(uint64 instruction, img_address m_pc);
+    std::string CMP_NE_D(uint64 instruction, img_address m_pc);
+    std::string CMP_NE_S(uint64 instruction, img_address m_pc);
+    std::string CMP_OR_D(uint64 instruction, img_address m_pc);
+    std::string CMP_OR_S(uint64 instruction, img_address m_pc);
+    std::string CMP_SAF_D(uint64 instruction, img_address m_pc);
+    std::string CMP_SAF_S(uint64 instruction, img_address m_pc);
+    std::string CMP_SEQ_D(uint64 instruction, img_address m_pc);
+    std::string CMP_SEQ_S(uint64 instruction, img_address m_pc);
+    std::string CMP_SLE_D(uint64 instruction, img_address m_pc);
+    std::string CMP_SLE_S(uint64 instruction, img_address m_pc);
+    std::string CMP_SLT_D(uint64 instruction, img_address m_pc);
+    std::string CMP_SLT_S(uint64 instruction, img_address m_pc);
+    std::string CMP_SNE_D(uint64 instruction, img_address m_pc);
+    std::string CMP_SNE_S(uint64 instruction, img_address m_pc);
+    std::string CMP_SOR_D(uint64 instruction, img_address m_pc);
+    std::string CMP_SOR_S(uint64 instruction, img_address m_pc);
+    std::string CMP_SUEQ_D(uint64 instruction, img_address m_pc);
+    std::string CMP_SUEQ_S(uint64 instruction, img_address m_pc);
+    std::string CMP_SULE_D(uint64 instruction, img_address m_pc);
+    std::string CMP_SULE_S(uint64 instruction, img_address m_pc);
+    std::string CMP_SULT_D(uint64 instruction, img_address m_pc);
+    std::string CMP_SULT_S(uint64 instruction, img_address m_pc);
+    std::string CMP_SUN_D(uint64 instruction, img_address m_pc);
+    std::string CMP_SUN_S(uint64 instruction, img_address m_pc);
+    std::string CMP_SUNE_D(uint64 instruction, img_address m_pc);
+    std::string CMP_SUNE_S(uint64 instruction, img_address m_pc);
+    std::string CMP_UEQ_D(uint64 instruction, img_address m_pc);
+    std::string CMP_UEQ_S(uint64 instruction, img_address m_pc);
+    std::string CMP_ULE_D(uint64 instruction, img_address m_pc);
+    std::string CMP_ULE_S(uint64 instruction, img_address m_pc);
+    std::string CMP_ULT_D(uint64 instruction, img_address m_pc);
+    std::string CMP_ULT_S(uint64 instruction, img_address m_pc);
+    std::string CMP_UN_D(uint64 instruction, img_address m_pc);
+    std::string CMP_UN_S(uint64 instruction, img_address m_pc);
+    std::string CMP_UNE_D(uint64 instruction, img_address m_pc);
+    std::string CMP_UNE_S(uint64 instruction, img_address m_pc);
+    std::string CMPGDU_EQ_QB(uint64 instruction, img_address m_pc);
+    std::string CMPGDU_LE_QB(uint64 instruction, img_address m_pc);
+    std::string CMPGDU_LT_QB(uint64 instruction, img_address m_pc);
+    std::string CMPGU_EQ_QB(uint64 instruction, img_address m_pc);
+    std::string CMPGU_LE_QB(uint64 instruction, img_address m_pc);
+    std::string CMPGU_LT_QB(uint64 instruction, img_address m_pc);
+    std::string CMPU_EQ_QB(uint64 instruction, img_address m_pc);
+    std::string CMPU_LE_QB(uint64 instruction, img_address m_pc);
+    std::string CMPU_LT_QB(uint64 instruction, img_address m_pc);
+    std::string COP2_1(uint64 instruction, img_address m_pc);
+    std::string CTC1(uint64 instruction, img_address m_pc);
+    std::string CTC2(uint64 instruction, img_address m_pc);
+    std::string CVT_D_L(uint64 instruction, img_address m_pc);
+    std::string CVT_D_S(uint64 instruction, img_address m_pc);
+    std::string CVT_D_W(uint64 instruction, img_address m_pc);
+    std::string CVT_L_D(uint64 instruction, img_address m_pc);
+    std::string CVT_L_S(uint64 instruction, img_address m_pc);
+    std::string CVT_S_D(uint64 instruction, img_address m_pc);
+    std::string CVT_S_L(uint64 instruction, img_address m_pc);
+    std::string CVT_S_PL(uint64 instruction, img_address m_pc);
+    std::string CVT_S_PU(uint64 instruction, img_address m_pc);
+    std::string CVT_S_W(uint64 instruction, img_address m_pc);
+    std::string CVT_W_D(uint64 instruction, img_address m_pc);
+    std::string CVT_W_S(uint64 instruction, img_address m_pc);
+    std::string DADDIU_48_(uint64 instruction, img_address m_pc);
+    std::string DADDIU_NEG_(uint64 instruction, img_address m_pc);
+    std::string DADDIU_U12_(uint64 instruction, img_address m_pc);
+    std::string DADD(uint64 instruction, img_address m_pc);
+    std::string DADDU(uint64 instruction, img_address m_pc);
+    std::string DCLO(uint64 instruction, img_address m_pc);
+    std::string DCLZ(uint64 instruction, img_address m_pc);
+    std::string DDIV(uint64 instruction, img_address m_pc);
+    std::string DDIVU(uint64 instruction, img_address m_pc);
+    std::string DERET(uint64 instruction, img_address m_pc);
+    std::string DEXTM(uint64 instruction, img_address m_pc);
+    std::string DEXT(uint64 instruction, img_address m_pc);
+    std::string DEXTU(uint64 instruction, img_address m_pc);
+    std::string DINSM(uint64 instruction, img_address m_pc);
+    std::string DINS(uint64 instruction, img_address m_pc);
+    std::string DINSU(uint64 instruction, img_address m_pc);
+    std::string DI(uint64 instruction, img_address m_pc);
+    std::string DIV(uint64 instruction, img_address m_pc);
+    std::string DIV_D(uint64 instruction, img_address m_pc);
+    std::string DIV_S(uint64 instruction, img_address m_pc);
+    std::string DIVU(uint64 instruction, img_address m_pc);
+    std::string DLSA(uint64 instruction, img_address m_pc);
+    std::string DLUI_48_(uint64 instruction, img_address m_pc);
+    std::string DMFC0(uint64 instruction, img_address m_pc);
+    std::string DMFC1(uint64 instruction, img_address m_pc);
+    std::string DMFC2(uint64 instruction, img_address m_pc);
+    std::string DMFGC0(uint64 instruction, img_address m_pc);
+    std::string DMOD(uint64 instruction, img_address m_pc);
+    std::string DMODU(uint64 instruction, img_address m_pc);
+    std::string DMTC0(uint64 instruction, img_address m_pc);
+    std::string DMTC1(uint64 instruction, img_address m_pc);
+    std::string DMTC2(uint64 instruction, img_address m_pc);
+    std::string DMTGC0(uint64 instruction, img_address m_pc);
+    std::string DMT(uint64 instruction, img_address m_pc);
+    std::string DMUH(uint64 instruction, img_address m_pc);
+    std::string DMUHU(uint64 instruction, img_address m_pc);
+    std::string DMUL(uint64 instruction, img_address m_pc);
+    std::string DMULU(uint64 instruction, img_address m_pc);
+    std::string DPAQ_S_W_PH(uint64 instruction, img_address m_pc);
+    std::string DPAQ_SA_L_W(uint64 instruction, img_address m_pc);
+    std::string DPAQX_S_W_PH(uint64 instruction, img_address m_pc);
+    std::string DPAQX_SA_W_PH(uint64 instruction, img_address m_pc);
+    std::string DPAU_H_QBL(uint64 instruction, img_address m_pc);
+    std::string DPAU_H_QBR(uint64 instruction, img_address m_pc);
+    std::string DPA_W_PH(uint64 instruction, img_address m_pc);
+    std::string DPAX_W_PH(uint64 instruction, img_address m_pc);
+    std::string DPS_W_PH(uint64 instruction, img_address m_pc);
+    std::string DPSQ_SA_L_W(uint64 instruction, img_address m_pc);
+    std::string DPSQ_S_W_PH(uint64 instruction, img_address m_pc);
+    std::string DPSQX_SA_W_PH(uint64 instruction, img_address m_pc);
+    std::string DPSQX_S_W_PH(uint64 instruction, img_address m_pc);
+    std::string DPSU_H_QBL(uint64 instruction, img_address m_pc);
+    std::string DPSU_H_QBR(uint64 instruction, img_address m_pc);
+    std::string DPSX_W_PH(uint64 instruction, img_address m_pc);
+    std::string DROTR(uint64 instruction, img_address m_pc);
+    std::string DROTR32(uint64 instruction, img_address m_pc);
+    std::string DROTRV(uint64 instruction, img_address m_pc);
+    std::string DROTX(uint64 instruction, img_address m_pc);
+    std::string DSLL(uint64 instruction, img_address m_pc);
+    std::string DSLL32(uint64 instruction, img_address m_pc);
+    std::string DSLLV(uint64 instruction, img_address m_pc);
+    std::string DSRA(uint64 instruction, img_address m_pc);
+    std::string DSRA32(uint64 instruction, img_address m_pc);
+    std::string DSRAV(uint64 instruction, img_address m_pc);
+    std::string DSRL32(uint64 instruction, img_address m_pc);
+    std::string DSRL(uint64 instruction, img_address m_pc);
+    std::string DSRLV(uint64 instruction, img_address m_pc);
+    std::string DSUB(uint64 instruction, img_address m_pc);
+    std::string DSUBU(uint64 instruction, img_address m_pc);
+    std::string DVP(uint64 instruction, img_address m_pc);
+    std::string DVPE(uint64 instruction, img_address m_pc);
+    std::string EHB(uint64 instruction, img_address m_pc);
+    std::string EI(uint64 instruction, img_address m_pc);
+    std::string EMT(uint64 instruction, img_address m_pc);
+    std::string ERET(uint64 instruction, img_address m_pc);
+    std::string ERETNC(uint64 instruction, img_address m_pc);
+    std::string EVP(uint64 instruction, img_address m_pc);
+    std::string EVPE(uint64 instruction, img_address m_pc);
+    std::string EXT(uint64 instruction, img_address m_pc);
+    std::string EXTD(uint64 instruction, img_address m_pc);
+    std::string EXTD32(uint64 instruction, img_address m_pc);
+    std::string EXTP(uint64 instruction, img_address m_pc);
+    std::string EXTPDP(uint64 instruction, img_address m_pc);
+    std::string EXTPDPV(uint64 instruction, img_address m_pc);
+    std::string EXTPV(uint64 instruction, img_address m_pc);
+    std::string EXTR_RS_W(uint64 instruction, img_address m_pc);
+    std::string EXTR_R_W(uint64 instruction, img_address m_pc);
+    std::string EXTR_S_H(uint64 instruction, img_address m_pc);
+    std::string EXTR_W(uint64 instruction, img_address m_pc);
+    std::string EXTRV_R_W(uint64 instruction, img_address m_pc);
+    std::string EXTRV_RS_W(uint64 instruction, img_address m_pc);
+    std::string EXTRV_S_H(uint64 instruction, img_address m_pc);
+    std::string EXTRV_W(uint64 instruction, img_address m_pc);
+    std::string EXTW(uint64 instruction, img_address m_pc);
+    std::string FLOOR_L_D(uint64 instruction, img_address m_pc);
+    std::string FLOOR_L_S(uint64 instruction, img_address m_pc);
+    std::string FLOOR_W_D(uint64 instruction, img_address m_pc);
+    std::string FLOOR_W_S(uint64 instruction, img_address m_pc);
+    std::string FORK(uint64 instruction, img_address m_pc);
+    std::string HYPCALL(uint64 instruction, img_address m_pc);
+    std::string HYPCALL_16_(uint64 instruction, img_address m_pc);
+    std::string INS(uint64 instruction, img_address m_pc);
+    std::string INSV(uint64 instruction, img_address m_pc);
+    std::string IRET(uint64 instruction, img_address m_pc);
+    std::string JALRC_16_(uint64 instruction, img_address m_pc);
+    std::string JALRC_32_(uint64 instruction, img_address m_pc);
+    std::string JALRC_HB(uint64 instruction, img_address m_pc);
+    std::string JRC(uint64 instruction, img_address m_pc);
+    std::string LB_16_(uint64 instruction, img_address m_pc);
+    std::string LB_GP_(uint64 instruction, img_address m_pc);
+    std::string LB_S9_(uint64 instruction, img_address m_pc);
+    std::string LB_U12_(uint64 instruction, img_address m_pc);
+    std::string LBE(uint64 instruction, img_address m_pc);
+    std::string LBU_16_(uint64 instruction, img_address m_pc);
+    std::string LBU_GP_(uint64 instruction, img_address m_pc);
+    std::string LBU_S9_(uint64 instruction, img_address m_pc);
+    std::string LBU_U12_(uint64 instruction, img_address m_pc);
+    std::string LBUE(uint64 instruction, img_address m_pc);
+    std::string LBUX(uint64 instruction, img_address m_pc);
+    std::string LBX(uint64 instruction, img_address m_pc);
+    std::string LD_GP_(uint64 instruction, img_address m_pc);
+    std::string LD_S9_(uint64 instruction, img_address m_pc);
+    std::string LD_U12_(uint64 instruction, img_address m_pc);
+    std::string LDC1_GP_(uint64 instruction, img_address m_pc);
+    std::string LDC1_S9_(uint64 instruction, img_address m_pc);
+    std::string LDC1_U12_(uint64 instruction, img_address m_pc);
+    std::string LDC1X(uint64 instruction, img_address m_pc);
+    std::string LDC1XS(uint64 instruction, img_address m_pc);
+    std::string LDC2(uint64 instruction, img_address m_pc);
+    std::string LDM(uint64 instruction, img_address m_pc);
+    std::string LDPC_48_(uint64 instruction, img_address m_pc);
+    std::string LDX(uint64 instruction, img_address m_pc);
+    std::string LDXS(uint64 instruction, img_address m_pc);
+    std::string LH_16_(uint64 instruction, img_address m_pc);
+    std::string LH_GP_(uint64 instruction, img_address m_pc);
+    std::string LH_S9_(uint64 instruction, img_address m_pc);
+    std::string LH_U12_(uint64 instruction, img_address m_pc);
+    std::string LHE(uint64 instruction, img_address m_pc);
+    std::string LHU_16_(uint64 instruction, img_address m_pc);
+    std::string LHU_GP_(uint64 instruction, img_address m_pc);
+    std::string LHU_S9_(uint64 instruction, img_address m_pc);
+    std::string LHU_U12_(uint64 instruction, img_address m_pc);
+    std::string LHUE(uint64 instruction, img_address m_pc);
+    std::string LHUX(uint64 instruction, img_address m_pc);
+    std::string LHUXS(uint64 instruction, img_address m_pc);
+    std::string LHX(uint64 instruction, img_address m_pc);
+    std::string LHXS(uint64 instruction, img_address m_pc);
+    std::string LI_16_(uint64 instruction, img_address m_pc);
+    std::string LI_48_(uint64 instruction, img_address m_pc);
+    std::string LL(uint64 instruction, img_address m_pc);
+    std::string LLD(uint64 instruction, img_address m_pc);
+    std::string LLDP(uint64 instruction, img_address m_pc);
+    std::string LLE(uint64 instruction, img_address m_pc);
+    std::string LLWP(uint64 instruction, img_address m_pc);
+    std::string LLWPE(uint64 instruction, img_address m_pc);
+    std::string LSA(uint64 instruction, img_address m_pc);
+    std::string LUI(uint64 instruction, img_address m_pc);
+    std::string LW_16_(uint64 instruction, img_address m_pc);
+    std::string LW_4X4_(uint64 instruction, img_address m_pc);
+    std::string LWC1_GP_(uint64 instruction, img_address m_pc);
+    std::string LWC1_S9_(uint64 instruction, img_address m_pc);
+    std::string LWC1_U12_(uint64 instruction, img_address m_pc);
+    std::string LWC1X(uint64 instruction, img_address m_pc);
+    std::string LWC1XS(uint64 instruction, img_address m_pc);
+    std::string LWC2(uint64 instruction, img_address m_pc);
+    std::string LWE(uint64 instruction, img_address m_pc);
+    std::string LW_GP_(uint64 instruction, img_address m_pc);
+    std::string LW_GP16_(uint64 instruction, img_address m_pc);
+    std::string LWM(uint64 instruction, img_address m_pc);
+    std::string LWPC_48_(uint64 instruction, img_address m_pc);
+    std::string LW_S9_(uint64 instruction, img_address m_pc);
+    std::string LW_SP_(uint64 instruction, img_address m_pc);
+    std::string LW_U12_(uint64 instruction, img_address m_pc);
+    std::string LWU_GP_(uint64 instruction, img_address m_pc);
+    std::string LWU_S9_(uint64 instruction, img_address m_pc);
+    std::string LWU_U12_(uint64 instruction, img_address m_pc);
+    std::string LWUX(uint64 instruction, img_address m_pc);
+    std::string LWUXS(uint64 instruction, img_address m_pc);
+    std::string LWX(uint64 instruction, img_address m_pc);
+    std::string LWXS_16_(uint64 instruction, img_address m_pc);
+    std::string LWXS_32_(uint64 instruction, img_address m_pc);
+    std::string MADD_DSP_(uint64 instruction, img_address m_pc);
+    std::string MADDF_D(uint64 instruction, img_address m_pc);
+    std::string MADDF_S(uint64 instruction, img_address m_pc);
+    std::string MADDU_DSP_(uint64 instruction, img_address m_pc);
+    std::string MAQ_S_W_PHL(uint64 instruction, img_address m_pc);
+    std::string MAQ_S_W_PHR(uint64 instruction, img_address m_pc);
+    std::string MAQ_SA_W_PHL(uint64 instruction, img_address m_pc);
+    std::string MAQ_SA_W_PHR(uint64 instruction, img_address m_pc);
+    std::string MAX_D(uint64 instruction, img_address m_pc);
+    std::string MAX_S(uint64 instruction, img_address m_pc);
+    std::string MAXA_D(uint64 instruction, img_address m_pc);
+    std::string MAXA_S(uint64 instruction, img_address m_pc);
+    std::string MFC0(uint64 instruction, img_address m_pc);
+    std::string MFC1(uint64 instruction, img_address m_pc);
+    std::string MFC2(uint64 instruction, img_address m_pc);
+    std::string MFGC0(uint64 instruction, img_address m_pc);
+    std::string MFHC0(uint64 instruction, img_address m_pc);
+    std::string MFHC1(uint64 instruction, img_address m_pc);
+    std::string MFHC2(uint64 instruction, img_address m_pc);
+    std::string MFHGC0(uint64 instruction, img_address m_pc);
+    std::string MFHI_DSP_(uint64 instruction, img_address m_pc);
+    std::string MFHTR(uint64 instruction, img_address m_pc);
+    std::string MFLO_DSP_(uint64 instruction, img_address m_pc);
+    std::string MFTR(uint64 instruction, img_address m_pc);
+    std::string MIN_D(uint64 instruction, img_address m_pc);
+    std::string MIN_S(uint64 instruction, img_address m_pc);
+    std::string MINA_D(uint64 instruction, img_address m_pc);
+    std::string MINA_S(uint64 instruction, img_address m_pc);
+    std::string MOD(uint64 instruction, img_address m_pc);
+    std::string MODSUB(uint64 instruction, img_address m_pc);
+    std::string MODU(uint64 instruction, img_address m_pc);
+    std::string MOV_D(uint64 instruction, img_address m_pc);
+    std::string MOV_S(uint64 instruction, img_address m_pc);
+    std::string MOVE_BALC(uint64 instruction, img_address m_pc);
+    std::string MOVEP(uint64 instruction, img_address m_pc);
+    std::string MOVEP_REV_(uint64 instruction, img_address m_pc);
+    std::string MOVE(uint64 instruction, img_address m_pc);
+    std::string MOVN(uint64 instruction, img_address m_pc);
+    std::string MOVZ(uint64 instruction, img_address m_pc);
+    std::string MSUB_DSP_(uint64 instruction, img_address m_pc);
+    std::string MSUBF_D(uint64 instruction, img_address m_pc);
+    std::string MSUBF_S(uint64 instruction, img_address m_pc);
+    std::string MSUBU_DSP_(uint64 instruction, img_address m_pc);
+    std::string MTC0(uint64 instruction, img_address m_pc);
+    std::string MTC1(uint64 instruction, img_address m_pc);
+    std::string MTC2(uint64 instruction, img_address m_pc);
+    std::string MTGC0(uint64 instruction, img_address m_pc);
+    std::string MTHC0(uint64 instruction, img_address m_pc);
+    std::string MTHC1(uint64 instruction, img_address m_pc);
+    std::string MTHC2(uint64 instruction, img_address m_pc);
+    std::string MTHGC0(uint64 instruction, img_address m_pc);
+    std::string MTHI_DSP_(uint64 instruction, img_address m_pc);
+    std::string MTHLIP(uint64 instruction, img_address m_pc);
+    std::string MTHTR(uint64 instruction, img_address m_pc);
+    std::string MTLO_DSP_(uint64 instruction, img_address m_pc);
+    std::string MTTR(uint64 instruction, img_address m_pc);
+    std::string MUH(uint64 instruction, img_address m_pc);
+    std::string MUHU(uint64 instruction, img_address m_pc);
+    std::string MUL_32_(uint64 instruction, img_address m_pc);
+    std::string MUL_4X4_(uint64 instruction, img_address m_pc);
+    std::string MUL_D(uint64 instruction, img_address m_pc);
+    std::string MUL_PH(uint64 instruction, img_address m_pc);
+    std::string MUL_S(uint64 instruction, img_address m_pc);
+    std::string MUL_S_PH(uint64 instruction, img_address m_pc);
+    std::string MULEQ_S_W_PHL(uint64 instruction, img_address m_pc);
+    std::string MULEQ_S_W_PHR(uint64 instruction, img_address m_pc);
+    std::string MULEU_S_PH_QBL(uint64 instruction, img_address m_pc);
+    std::string MULEU_S_PH_QBR(uint64 instruction, img_address m_pc);
+    std::string MULQ_RS_PH(uint64 instruction, img_address m_pc);
+    std::string MULQ_RS_W(uint64 instruction, img_address m_pc);
+    std::string MULQ_S_PH(uint64 instruction, img_address m_pc);
+    std::string MULQ_S_W(uint64 instruction, img_address m_pc);
+    std::string MULSA_W_PH(uint64 instruction, img_address m_pc);
+    std::string MULSAQ_S_W_PH(uint64 instruction, img_address m_pc);
+    std::string MULT_DSP_(uint64 instruction, img_address m_pc);
+    std::string MULTU_DSP_(uint64 instruction, img_address m_pc);
+    std::string MULU(uint64 instruction, img_address m_pc);
+    std::string NEG_D(uint64 instruction, img_address m_pc);
+    std::string NEG_S(uint64 instruction, img_address m_pc);
+    std::string NOP_16_(uint64 instruction, img_address m_pc);
+    std::string NOP_32_(uint64 instruction, img_address m_pc);
+    std::string NOR(uint64 instruction, img_address m_pc);
+    std::string NOT_16_(uint64 instruction, img_address m_pc);
+    std::string OR_16_(uint64 instruction, img_address m_pc);
+    std::string OR_32_(uint64 instruction, img_address m_pc);
+    std::string ORI(uint64 instruction, img_address m_pc);
+    std::string PACKRL_PH(uint64 instruction, img_address m_pc);
+    std::string PAUSE(uint64 instruction, img_address m_pc);
+    std::string PICK_PH(uint64 instruction, img_address m_pc);
+    std::string PICK_QB(uint64 instruction, img_address m_pc);
+    std::string PRECEQ_W_PHL(uint64 instruction, img_address m_pc);
+    std::string PRECEQ_W_PHR(uint64 instruction, img_address m_pc);
+    std::string PRECEQU_PH_QBL(uint64 instruction, img_address m_pc);
+    std::string PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc);
+    std::string PRECEQU_PH_QBR(uint64 instruction, img_address m_pc);
+    std::string PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc);
+    std::string PRECEU_PH_QBL(uint64 instruction, img_address m_pc);
+    std::string PRECEU_PH_QBLA(uint64 instruction, img_address m_pc);
+    std::string PRECEU_PH_QBR(uint64 instruction, img_address m_pc);
+    std::string PRECEU_PH_QBRA(uint64 instruction, img_address m_pc);
+    std::string PRECR_QB_PH(uint64 instruction, img_address m_pc);
+    std::string PRECR_SRA_PH_W(uint64 instruction, img_address m_pc);
+    std::string PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc);
+    std::string PRECRQ_PH_W(uint64 instruction, img_address m_pc);
+    std::string PRECRQ_QB_PH(uint64 instruction, img_address m_pc);
+    std::string PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc);
+    std::string PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc);
+    std::string PREF_S9_(uint64 instruction, img_address m_pc);
+    std::string PREF_U12_(uint64 instruction, img_address m_pc);
+    std::string PREFE(uint64 instruction, img_address m_pc);
+    std::string PREPEND(uint64 instruction, img_address m_pc);
+    std::string RADDU_W_QB(uint64 instruction, img_address m_pc);
+    std::string RDDSP(uint64 instruction, img_address m_pc);
+    std::string RDHWR(uint64 instruction, img_address m_pc);
+    std::string RDPGPR(uint64 instruction, img_address m_pc);
+    std::string RECIP_D(uint64 instruction, img_address m_pc);
+    std::string RECIP_S(uint64 instruction, img_address m_pc);
+    std::string REPL_PH(uint64 instruction, img_address m_pc);
+    std::string REPL_QB(uint64 instruction, img_address m_pc);
+    std::string REPLV_PH(uint64 instruction, img_address m_pc);
+    std::string REPLV_QB(uint64 instruction, img_address m_pc);
+    std::string RESTORE_32_(uint64 instruction, img_address m_pc);
+    std::string RESTORE_JRC_16_(uint64 instruction, img_address m_pc);
+    std::string RESTORE_JRC_32_(uint64 instruction, img_address m_pc);
+    std::string RESTOREF(uint64 instruction, img_address m_pc);
+    std::string RINT_D(uint64 instruction, img_address m_pc);
+    std::string RINT_S(uint64 instruction, img_address m_pc);
+    std::string ROTR(uint64 instruction, img_address m_pc);
+    std::string ROTRV(uint64 instruction, img_address m_pc);
+    std::string ROTX(uint64 instruction, img_address m_pc);
+    std::string ROUND_L_D(uint64 instruction, img_address m_pc);
+    std::string ROUND_L_S(uint64 instruction, img_address m_pc);
+    std::string ROUND_W_D(uint64 instruction, img_address m_pc);
+    std::string ROUND_W_S(uint64 instruction, img_address m_pc);
+    std::string RSQRT_D(uint64 instruction, img_address m_pc);
+    std::string RSQRT_S(uint64 instruction, img_address m_pc);
+    std::string SAVE_16_(uint64 instruction, img_address m_pc);
+    std::string SAVE_32_(uint64 instruction, img_address m_pc);
+    std::string SAVEF(uint64 instruction, img_address m_pc);
+    std::string SB_16_(uint64 instruction, img_address m_pc);
+    std::string SB_GP_(uint64 instruction, img_address m_pc);
+    std::string SB_S9_(uint64 instruction, img_address m_pc);
+    std::string SB_U12_(uint64 instruction, img_address m_pc);
+    std::string SBE(uint64 instruction, img_address m_pc);
+    std::string SBX(uint64 instruction, img_address m_pc);
+    std::string SC(uint64 instruction, img_address m_pc);
+    std::string SCD(uint64 instruction, img_address m_pc);
+    std::string SCDP(uint64 instruction, img_address m_pc);
+    std::string SCE(uint64 instruction, img_address m_pc);
+    std::string SCWP(uint64 instruction, img_address m_pc);
+    std::string SCWPE(uint64 instruction, img_address m_pc);
+    std::string SD_GP_(uint64 instruction, img_address m_pc);
+    std::string SD_S9_(uint64 instruction, img_address m_pc);
+    std::string SD_U12_(uint64 instruction, img_address m_pc);
+    std::string SDBBP_16_(uint64 instruction, img_address m_pc);
+    std::string SDBBP_32_(uint64 instruction, img_address m_pc);
+    std::string SDC1_GP_(uint64 instruction, img_address m_pc);
+    std::string SDC1_S9_(uint64 instruction, img_address m_pc);
+    std::string SDC1_U12_(uint64 instruction, img_address m_pc);
+    std::string SDC1X(uint64 instruction, img_address m_pc);
+    std::string SDC1XS(uint64 instruction, img_address m_pc);
+    std::string SDC2(uint64 instruction, img_address m_pc);
+    std::string SDM(uint64 instruction, img_address m_pc);
+    std::string SDPC_48_(uint64 instruction, img_address m_pc);
+    std::string SDX(uint64 instruction, img_address m_pc);
+    std::string SDXS(uint64 instruction, img_address m_pc);
+    std::string SEB(uint64 instruction, img_address m_pc);
+    std::string SEH(uint64 instruction, img_address m_pc);
+    std::string SEL_D(uint64 instruction, img_address m_pc);
+    std::string SEL_S(uint64 instruction, img_address m_pc);
+    std::string SELEQZ_D(uint64 instruction, img_address m_pc);
+    std::string SELEQZ_S(uint64 instruction, img_address m_pc);
+    std::string SELNEZ_D(uint64 instruction, img_address m_pc);
+    std::string SELNEZ_S(uint64 instruction, img_address m_pc);
+    std::string SEQI(uint64 instruction, img_address m_pc);
+    std::string SH_16_(uint64 instruction, img_address m_pc);
+    std::string SH_GP_(uint64 instruction, img_address m_pc);
+    std::string SH_S9_(uint64 instruction, img_address m_pc);
+    std::string SH_U12_(uint64 instruction, img_address m_pc);
+    std::string SHE(uint64 instruction, img_address m_pc);
+    std::string SHILO(uint64 instruction, img_address m_pc);
+    std::string SHILOV(uint64 instruction, img_address m_pc);
+    std::string SHLL_PH(uint64 instruction, img_address m_pc);
+    std::string SHLL_QB(uint64 instruction, img_address m_pc);
+    std::string SHLL_S_PH(uint64 instruction, img_address m_pc);
+    std::string SHLL_S_W(uint64 instruction, img_address m_pc);
+    std::string SHLLV_PH(uint64 instruction, img_address m_pc);
+    std::string SHLLV_QB(uint64 instruction, img_address m_pc);
+    std::string SHLLV_S_PH(uint64 instruction, img_address m_pc);
+    std::string SHLLV_S_W(uint64 instruction, img_address m_pc);
+    std::string SHRA_PH(uint64 instruction, img_address m_pc);
+    std::string SHRA_QB(uint64 instruction, img_address m_pc);
+    std::string SHRA_R_PH(uint64 instruction, img_address m_pc);
+    std::string SHRA_R_QB(uint64 instruction, img_address m_pc);
+    std::string SHRA_R_W(uint64 instruction, img_address m_pc);
+    std::string SHRAV_PH(uint64 instruction, img_address m_pc);
+    std::string SHRAV_QB(uint64 instruction, img_address m_pc);
+    std::string SHRAV_R_PH(uint64 instruction, img_address m_pc);
+    std::string SHRAV_R_QB(uint64 instruction, img_address m_pc);
+    std::string SHRAV_R_W(uint64 instruction, img_address m_pc);
+    std::string SHRL_PH(uint64 instruction, img_address m_pc);
+    std::string SHRL_QB(uint64 instruction, img_address m_pc);
+    std::string SHRLV_PH(uint64 instruction, img_address m_pc);
+    std::string SHRLV_QB(uint64 instruction, img_address m_pc);
+    std::string SHX(uint64 instruction, img_address m_pc);
+    std::string SHXS(uint64 instruction, img_address m_pc);
+    std::string SIGRIE(uint64 instruction, img_address m_pc);
+    std::string SLL_16_(uint64 instruction, img_address m_pc);
+    std::string SLL_32_(uint64 instruction, img_address m_pc);
+    std::string SLLV(uint64 instruction, img_address m_pc);
+    std::string SLT(uint64 instruction, img_address m_pc);
+    std::string SLTI(uint64 instruction, img_address m_pc);
+    std::string SLTIU(uint64 instruction, img_address m_pc);
+    std::string SLTU(uint64 instruction, img_address m_pc);
+    std::string SOV(uint64 instruction, img_address m_pc);
+    std::string SPECIAL2(uint64 instruction, img_address m_pc);
+    std::string SQRT_D(uint64 instruction, img_address m_pc);
+    std::string SQRT_S(uint64 instruction, img_address m_pc);
+    std::string SRA(uint64 instruction, img_address m_pc);
+    std::string SRAV(uint64 instruction, img_address m_pc);
+    std::string SRL_16_(uint64 instruction, img_address m_pc);
+    std::string SRL_32_(uint64 instruction, img_address m_pc);
+    std::string SRLV(uint64 instruction, img_address m_pc);
+    std::string SUB(uint64 instruction, img_address m_pc);
+    std::string SUB_D(uint64 instruction, img_address m_pc);
+    std::string SUB_S(uint64 instruction, img_address m_pc);
+    std::string SUBQ_PH(uint64 instruction, img_address m_pc);
+    std::string SUBQ_S_PH(uint64 instruction, img_address m_pc);
+    std::string SUBQ_S_W(uint64 instruction, img_address m_pc);
+    std::string SUBQH_PH(uint64 instruction, img_address m_pc);
+    std::string SUBQH_R_PH(uint64 instruction, img_address m_pc);
+    std::string SUBQH_R_W(uint64 instruction, img_address m_pc);
+    std::string SUBQH_W(uint64 instruction, img_address m_pc);
+    std::string SUBU_16_(uint64 instruction, img_address m_pc);
+    std::string SUBU_32_(uint64 instruction, img_address m_pc);
+    std::string SUBU_PH(uint64 instruction, img_address m_pc);
+    std::string SUBU_QB(uint64 instruction, img_address m_pc);
+    std::string SUBU_S_PH(uint64 instruction, img_address m_pc);
+    std::string SUBU_S_QB(uint64 instruction, img_address m_pc);
+    std::string SUBUH_QB(uint64 instruction, img_address m_pc);
+    std::string SUBUH_R_QB(uint64 instruction, img_address m_pc);
+    std::string SW_16_(uint64 instruction, img_address m_pc);
+    std::string SW_4X4_(uint64 instruction, img_address m_pc);
+    std::string SW_GP16_(uint64 instruction, img_address m_pc);
+    std::string SW_GP_(uint64 instruction, img_address m_pc);
+    std::string SW_S9_(uint64 instruction, img_address m_pc);
+    std::string SW_SP_(uint64 instruction, img_address m_pc);
+    std::string SW_U12_(uint64 instruction, img_address m_pc);
+    std::string SWC1_GP_(uint64 instruction, img_address m_pc);
+    std::string SWC1_S9_(uint64 instruction, img_address m_pc);
+    std::string SWC1_U12_(uint64 instruction, img_address m_pc);
+    std::string SWC1X(uint64 instruction, img_address m_pc);
+    std::string SWC1XS(uint64 instruction, img_address m_pc);
+    std::string SWC2(uint64 instruction, img_address m_pc);
+    std::string SWE(uint64 instruction, img_address m_pc);
+    std::string SWM(uint64 instruction, img_address m_pc);
+    std::string SWPC_48_(uint64 instruction, img_address m_pc);
+    std::string SWX(uint64 instruction, img_address m_pc);
+    std::string SWXS(uint64 instruction, img_address m_pc);
+    std::string SYNC(uint64 instruction, img_address m_pc);
+    std::string SYNCI(uint64 instruction, img_address m_pc);
+    std::string SYNCIE(uint64 instruction, img_address m_pc);
+    std::string SYSCALL_16_(uint64 instruction, img_address m_pc);
+    std::string SYSCALL_32_(uint64 instruction, img_address m_pc);
+    std::string TEQ(uint64 instruction, img_address m_pc);
+    std::string TLBGINV(uint64 instruction, img_address m_pc);
+    std::string TLBGINVF(uint64 instruction, img_address m_pc);
+    std::string TLBGP(uint64 instruction, img_address m_pc);
+    std::string TLBGR(uint64 instruction, img_address m_pc);
+    std::string TLBGWI(uint64 instruction, img_address m_pc);
+    std::string TLBGWR(uint64 instruction, img_address m_pc);
+    std::string TLBINV(uint64 instruction, img_address m_pc);
+    std::string TLBINVF(uint64 instruction, img_address m_pc);
+    std::string TLBP(uint64 instruction, img_address m_pc);
+    std::string TLBR(uint64 instruction, img_address m_pc);
+    std::string TLBWI(uint64 instruction, img_address m_pc);
+    std::string TLBWR(uint64 instruction, img_address m_pc);
+    std::string TNE(uint64 instruction, img_address m_pc);
+    std::string TRUNC_L_D(uint64 instruction, img_address m_pc);
+    std::string TRUNC_L_S(uint64 instruction, img_address m_pc);
+    std::string TRUNC_W_D(uint64 instruction, img_address m_pc);
+    std::string TRUNC_W_S(uint64 instruction, img_address m_pc);
+    std::string UALDM(uint64 instruction, img_address m_pc);
+    std::string UALH(uint64 instruction, img_address m_pc);
+    std::string UALWM(uint64 instruction, img_address m_pc);
+    std::string UASDM(uint64 instruction, img_address m_pc);
+    std::string UASH(uint64 instruction, img_address m_pc);
+    std::string UASWM(uint64 instruction, img_address m_pc);
+    std::string UDI(uint64 instruction, img_address m_pc);
+    std::string WAIT(uint64 instruction, img_address m_pc);
+    std::string WRDSP(uint64 instruction, img_address m_pc);
+    std::string WRPGPR(uint64 instruction, img_address m_pc);
+    std::string XOR_16_(uint64 instruction, img_address m_pc);
+    std::string XOR_32_(uint64 instruction, img_address m_pc);
+    std::string XORI(uint64 instruction, img_address m_pc);
+    std::string YIELD(uint64 instruction, img_address m_pc);
 
     static Pool P_SYSCALL[2];
     static Pool P_RI[4];
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 03/20] disas/nanomips: Delete NMD class fields
  2022-09-05  9:55 ` [PATCH v2 03/20] disas/nanomips: Delete NMD class fields Milica Lazarevic
@ 2022-09-05 11:04   ` Richard Henderson
  2022-09-05 11:53     ` Richard Henderson
  0 siblings, 1 reply; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:04 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> Two class fields have been deleted.
> 
> Since the m_requested_instruction_categories field always has the same
> value, which is ALL_ATTRIBUTES, the only use of that field has been
> replaced with the concrete ALL_ATTRIBUTES value.

Since these ALL_ATTRIBUTES tests are always true, you could just remove them.


> The second class field m_pc is added as a parameter where needed.
> Therefore, prototypes of the following functions have been changed:
> - public NMD::Disassemble method
> - private NMD::Disassemble method
> - NMD::ADDRESS method
> - all of the disassembly_function methods
> 
> Accordingly, the disassembly_function typedef has been changed.

Fine.

These two changes should be done separately.


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 03/20] disas/nanomips: Delete NMD class fields
  2022-09-05 11:04   ` Richard Henderson
@ 2022-09-05 11:53     ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:53 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 12:04, Richard Henderson wrote:
> On 9/5/22 10:55, Milica Lazarevic wrote:
>> Two class fields have been deleted.
>>
>> Since the m_requested_instruction_categories field always has the same
>> value, which is ALL_ATTRIBUTES, the only use of that field has been
>> replaced with the concrete ALL_ATTRIBUTES value.
> 
> Since these ALL_ATTRIBUTES tests are always true, you could just remove them.
> 
> 
>> The second class field m_pc is added as a parameter where needed.
>> Therefore, prototypes of the following functions have been changed:
>> - public NMD::Disassemble method
>> - private NMD::Disassemble method
>> - NMD::ADDRESS method
>> - all of the disassembly_function methods
>>
>> Accordingly, the disassembly_function typedef has been changed.


Actually, you might as well introduce

struct Dis_info {
     uint64_t m_pc;
};

now, so that you don't have to replace all of this parameter again in patch 15.


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 04/20] disas/nanomips: Remove helper methods from class
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (2 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 03/20] disas/nanomips: Delete NMD class fields Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:05   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 05/20] disas/nanomips: Remove __cond " Milica Lazarevic
                   ` (15 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

Helper methods from NMD class like NMD::renumber_registers,
NMD::decode_gpr_gpr4... etc. are removed from the class. They're now
declared global static functions.

Following helper methods have been deleted because they're not used by
the nanomips disassembler:
- NMD::encode_msbd_from_pos_and_size,
- NMD::encode_s_from_s_hi,
- NMD::neg_copy

Global functions used by those methods:
- nanomips_dis
- sign_extend
- extract_bits
have also been defined as static global functions.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
---
 disas/nanomips.cpp | 328 +++++++++++++++++++++------------------------
 disas/nanomips.h   | 144 --------------------
 2 files changed, 154 insertions(+), 318 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index 49cdf23dbc..91ea35bf75 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -41,7 +41,7 @@
 #define IMGASSERTONCE(test)
 
 
-int nanomips_dis(char *buf,
+static int nanomips_dis(char *buf,
                  unsigned address,
                  unsigned short one,
                  unsigned short two,
@@ -256,20 +256,20 @@ std::string to_string(img_address a)
 }
 
 
-uint64 extract_bits(uint64 data, uint32 bit_offset, uint32 bit_size)
+static uint64 extract_bits(uint64 data, uint32 bit_offset, uint32 bit_size)
 {
     return (data << (64 - (bit_size + bit_offset))) >> (64 - bit_size);
 }
 
 
-int64 sign_extend(int64 data, int msb)
+static int64 sign_extend(int64 data, int msb)
 {
     uint64 shift = 63 - msb;
     return (data << shift) >> shift;
 }
 
 
-uint64 NMD::renumber_registers(uint64 index, uint64 *register_list,
+static uint64 renumber_registers(uint64 index, uint64 *register_list,
                                size_t register_list_size)
 {
     if (index < register_list_size) {
@@ -284,7 +284,7 @@ uint64 NMD::renumber_registers(uint64 index, uint64 *register_list,
 
 
 /*
- * NMD::decode_gpr_gpr4() - decoder for 'gpr4' gpr encoding type
+ * decode_gpr_gpr4() - decoder for 'gpr4' gpr encoding type
  *
  *   Map a 4-bit code to the 5-bit register space according to this pattern:
  *
@@ -309,7 +309,7 @@ uint64 NMD::renumber_registers(uint64 index, uint64 *register_list,
  *     - MUL[4X4]
  *     - SW[4X4]
  */
-uint64 NMD::decode_gpr_gpr4(uint64 d)
+static uint64 decode_gpr_gpr4(uint64 d)
 {
     static uint64 register_list[] = {  8,  9, 10, 11,  4,  5,  6,  7,
                                       16, 17, 18, 19, 20, 21, 22, 23 };
@@ -319,7 +319,7 @@ uint64 NMD::decode_gpr_gpr4(uint64 d)
 
 
 /*
- * NMD::decode_gpr_gpr4_zero() - decoder for 'gpr4.zero' gpr encoding type
+ * decode_gpr_gpr4_zero() - decoder for 'gpr4.zero' gpr encoding type
  *
  *   Map a 4-bit code to the 5-bit register space according to this pattern:
  *
@@ -345,7 +345,7 @@ uint64 NMD::decode_gpr_gpr4(uint64 d)
  *     - MOVEP
  *     - SW[4X4]
  */
-uint64 NMD::decode_gpr_gpr4_zero(uint64 d)
+static uint64 decode_gpr_gpr4_zero(uint64 d)
 {
     static uint64 register_list[] = {  8,  9, 10,  0,  4,  5,  6,  7,
                                       16, 17, 18, 19, 20, 21, 22, 23 };
@@ -355,7 +355,7 @@ uint64 NMD::decode_gpr_gpr4_zero(uint64 d)
 
 
 /*
- * NMD::decode_gpr_gpr3() - decoder for 'gpr3' gpr encoding type
+ * decode_gpr_gpr3() - decoder for 'gpr3' gpr encoding type
  *
  *   Map a 3-bit code to the 5-bit register space according to this pattern:
  *
@@ -404,7 +404,7 @@ uint64 NMD::decode_gpr_gpr4_zero(uint64 d)
  *     - SW[16]
  *     - XOR[16]
  */
-uint64 NMD::decode_gpr_gpr3(uint64 d)
+static uint64 decode_gpr_gpr3(uint64 d)
 {
     static uint64 register_list[] = { 16, 17, 18, 19,  4,  5,  6,  7 };
     return renumber_registers(d, register_list,
@@ -413,7 +413,7 @@ uint64 NMD::decode_gpr_gpr3(uint64 d)
 
 
 /*
- * NMD::decode_gpr_gpr3_src_store() - decoder for 'gpr3.src.store' gpr encoding
+ * decode_gpr_gpr3_src_store() - decoder for 'gpr3.src.store' gpr encoding
  *     type
  *
  *   Map a 3-bit code to the 5-bit register space according to this pattern:
@@ -444,7 +444,7 @@ uint64 NMD::decode_gpr_gpr3(uint64 d)
  *     - SW[16]
  *     - SW[GP16]
  */
-uint64 NMD::decode_gpr_gpr3_src_store(uint64 d)
+static uint64 decode_gpr_gpr3_src_store(uint64 d)
 {
     static uint64 register_list[] = {  0, 17, 18, 19,  4,  5,  6,  7 };
     return renumber_registers(d, register_list,
@@ -453,7 +453,7 @@ uint64 NMD::decode_gpr_gpr3_src_store(uint64 d)
 
 
 /*
- * NMD::decode_gpr_gpr2_reg1() - decoder for 'gpr2.reg1' gpr encoding type
+ * decode_gpr_gpr2_reg1() - decoder for 'gpr2.reg1' gpr encoding type
  *
  *   Map a 2-bit code to the 5-bit register space according to this pattern:
  *
@@ -474,7 +474,7 @@ uint64 NMD::decode_gpr_gpr3_src_store(uint64 d)
  *     - MOVEP
  *     - MOVEP[REV]
  */
-uint64 NMD::decode_gpr_gpr2_reg1(uint64 d)
+static uint64 decode_gpr_gpr2_reg1(uint64 d)
 {
     static uint64 register_list[] = {  4,  5,  6,  7 };
     return renumber_registers(d, register_list,
@@ -483,7 +483,7 @@ uint64 NMD::decode_gpr_gpr2_reg1(uint64 d)
 
 
 /*
- * NMD::decode_gpr_gpr2_reg2() - decoder for 'gpr2.reg2' gpr encoding type
+ * decode_gpr_gpr2_reg2() - decoder for 'gpr2.reg2' gpr encoding type
  *
  *   Map a 2-bit code to the 5-bit register space according to this pattern:
  *
@@ -504,7 +504,7 @@ uint64 NMD::decode_gpr_gpr2_reg1(uint64 d)
  *     - MOVEP
  *     - MOVEP[REV]
  */
-uint64 NMD::decode_gpr_gpr2_reg2(uint64 d)
+static uint64 decode_gpr_gpr2_reg2(uint64 d)
 {
     static uint64 register_list[] = {  5,  6,  7,  8 };
     return renumber_registers(d, register_list,
@@ -513,7 +513,7 @@ uint64 NMD::decode_gpr_gpr2_reg2(uint64 d)
 
 
 /*
- * NMD::decode_gpr_gpr1() - decoder for 'gpr1' gpr encoding type
+ * decode_gpr_gpr1() - decoder for 'gpr1' gpr encoding type
  *
  *   Map a 1-bit code to the 5-bit register space according to this pattern:
  *
@@ -533,7 +533,7 @@ uint64 NMD::decode_gpr_gpr2_reg2(uint64 d)
  *
  *     - MOVE.BALC
  */
-uint64 NMD::decode_gpr_gpr1(uint64 d)
+static uint64 decode_gpr_gpr1(uint64 d)
 {
     static uint64 register_list[] = {  4,  5 };
     return renumber_registers(d, register_list,
@@ -541,73 +541,60 @@ uint64 NMD::decode_gpr_gpr1(uint64 d)
 }
 
 
-uint64 NMD::copy(uint64 d)
+static uint64 copy(uint64 d)
 {
     return d;
 }
 
 
-int64 NMD::copy(int64 d)
+static int64 copy(int64 d)
 {
     return d;
 }
 
 
-int64 NMD::neg_copy(uint64 d)
+static int64 neg_copy(uint64 d)
 {
     return 0ll - d;
 }
 
 
-int64 NMD::neg_copy(int64 d)
-{
-    return -d;
-}
-
-
 /* strange wrapper around  gpr3 */
-uint64 NMD::encode_rs3_and_check_rs3_ge_rt3(uint64 d)
+static uint64 encode_rs3_and_check_rs3_ge_rt3(uint64 d)
 {
 return decode_gpr_gpr3(d);
 }
 
 
 /* strange wrapper around  gpr3 */
-uint64 NMD::encode_rs3_and_check_rs3_lt_rt3(uint64 d)
+static uint64 encode_rs3_and_check_rs3_lt_rt3(uint64 d)
 {
     return decode_gpr_gpr3(d);
 }
 
 
 /* nop - done by extraction function */
-uint64 NMD::encode_s_from_address(uint64 d)
+static uint64 encode_s_from_address(uint64 d)
 {
     return d;
 }
 
 
 /* nop - done by extraction function */
-uint64 NMD::encode_u_from_address(uint64 d)
+static uint64 encode_u_from_address(uint64 d)
 {
     return d;
 }
 
 
-/* nop - done by extraction function */
-uint64 NMD::encode_s_from_s_hi(uint64 d)
-{
-    return d;
-}
-
-
-uint64 NMD::encode_count3_from_count(uint64 d)
+static uint64 encode_count3_from_count(uint64 d)
 {
     IMGASSERTONCE(d < 8);
     return d == 0ull ? 8ull : d;
 }
 
 
-uint64 NMD::encode_shift3_from_shift(uint64 d)
+static uint64 encode_shift3_from_shift(uint64 d)
 {
     IMGASSERTONCE(d < 8);
     return d == 0ull ? 8ull : d;
@@ -615,21 +602,21 @@ uint64 NMD::encode_shift3_from_shift(uint64 d)
 
 
 /* special value for load literal */
-int64 NMD::encode_eu_from_s_li16(uint64 d)
+static int64 encode_eu_from_s_li16(uint64 d)
 {
     IMGASSERTONCE(d < 128);
     return d == 127 ? -1 : (int64)d;
 }
 
 
-uint64 NMD::encode_msbd_from_size(uint64 d)
+static uint64 encode_msbd_from_size(uint64 d)
 {
     IMGASSERTONCE(d < 32);
     return d + 1;
 }
 
 
-uint64 NMD::encode_eu_from_u_andi16(uint64 d)
+static uint64 encode_eu_from_u_andi16(uint64 d)
 {
     IMGASSERTONCE(d < 16);
     if (d == 12) {
@@ -642,42 +629,21 @@ uint64 NMD::encode_eu_from_u_andi16(uint64 d)
 }
 
 
-uint64 NMD::encode_msbd_from_pos_and_size(uint64 d)
-{
-    IMGASSERTONCE(0);
-    return d;
-}
-
-
 /* save16 / restore16   ???? */
-uint64 NMD::encode_rt1_from_rt(uint64 d)
+static uint64 encode_rt1_from_rt(uint64 d)
 {
     return d ? 31 : 30;
 }
 
 
 /* ? */
-uint64 NMD::encode_lsb_from_pos_and_size(uint64 d)
+static uint64 encode_lsb_from_pos_and_size(uint64 d)
 {
     return d;
 }
 
 
-std::string NMD::save_restore_list(uint64 rt, uint64 count, uint64 gp)
-{
-    std::string str;
-
-    for (uint64 counter = 0; counter != count; counter++) {
-        bool use_gp = gp && (counter == count - 1);
-        uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
-        str += img_format(",%s", GPR(this_rt));
-    }
-
-    return str;
-}
-
-
-std::string NMD::GPR(uint64 reg)
+static std::string GPR(uint64 reg)
 {
     static const char *gpr_reg[32] = {
         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
@@ -695,7 +661,21 @@ std::string NMD::GPR(uint64 reg)
 }
 
 
-std::string NMD::FPR(uint64 reg)
+static std::string save_restore_list(uint64 rt, uint64 count, uint64 gp)
+{
+    std::string str;
+
+    for (uint64 counter = 0; counter != count; counter++) {
+        bool use_gp = gp && (counter == count - 1);
+        uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
+        str += img_format(",%s", GPR(this_rt));
+    }
+
+    return str;
+}
+
+
+static std::string FPR(uint64 reg)
 {
     static const char *fpr_reg[32] = {
         "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
@@ -713,7 +693,7 @@ std::string NMD::FPR(uint64 reg)
 }
 
 
-std::string NMD::AC(uint64 reg)
+static std::string AC(uint64 reg)
 {
     static const char *ac_reg[4] = {
         "ac0",  "ac1",  "ac2",  "ac3"
@@ -728,26 +708,26 @@ std::string NMD::AC(uint64 reg)
 }
 
 
-std::string NMD::IMMEDIATE(uint64 value)
+static std::string IMMEDIATE(uint64 value)
 {
     return img_format("0x%" PRIx64, value);
 }
 
 
-std::string NMD::IMMEDIATE(int64 value)
+static std::string IMMEDIATE(int64 value)
 {
     return img_format("%" PRId64, value);
 }
 
 
-std::string NMD::CPR(uint64 reg)
+static std::string CPR(uint64 reg)
 {
     /* needs more work */
     return img_format("CP%" PRIu64, reg);
 }
 
 
-std::string NMD::ADDRESS(uint64 value, int instruction_size, img_address m_pc)
+static std::string ADDRESS(uint64 value, int instruction_size, img_address m_pc)
 {
     /* token for string replace */
     img_address address = m_pc + value + instruction_size;
@@ -855,7 +835,7 @@ int NMD::Disassemble(const uint16 * data, std::string & dis,
 }
 
 
-uint64 NMD::extract_code_18_to_0(uint64 instruction)
+static uint64 extract_code_18_to_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 19);
@@ -863,7 +843,7 @@ uint64 NMD::extract_code_18_to_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_shift3_2_1_0(uint64 instruction)
+static uint64 extract_shift3_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 3);
@@ -871,7 +851,7 @@ uint64 NMD::extract_shift3_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3__s3(uint64 instruction)
+static uint64 extract_u_11_10_9_8_7_6_5_4_3__s3(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 3, 9) << 3;
@@ -879,7 +859,7 @@ uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3__s3(uint64 instruction)
 }
 
 
-uint64 NMD::extract_count_3_2_1_0(uint64 instruction)
+static uint64 extract_count_3_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 4);
@@ -887,7 +867,7 @@ uint64 NMD::extract_count_3_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rtz3_9_8_7(uint64 instruction)
+static uint64 extract_rtz3_9_8_7(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 7, 3);
@@ -895,7 +875,7 @@ uint64 NMD::extract_rtz3_9_8_7(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_17_to_1__s1(uint64 instruction)
+static uint64 extract_u_17_to_1__s1(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 1, 17) << 1;
@@ -903,7 +883,7 @@ uint64 NMD::extract_u_17_to_1__s1(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se9_20_19_18_17_16_15_14_13_12_11(uint64 instruction)
+static int64 extract_s__se9_20_19_18_17_16_15_14_13_12_11(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 11, 10);
@@ -912,7 +892,7 @@ int64 NMD::extract_s__se9_20_19_18_17_16_15_14_13_12_11(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(uint64 instruction)
+static int64 extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 0, 1) << 11;
@@ -922,7 +902,7 @@ int64 NMD::extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_10(uint64 instruction)
+static uint64 extract_u_10(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 10, 1);
@@ -930,7 +910,7 @@ uint64 NMD::extract_u_10(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rtz4_27_26_25_23_22_21(uint64 instruction)
+static uint64 extract_rtz4_27_26_25_23_22_21(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 21, 3);
@@ -939,7 +919,7 @@ uint64 NMD::extract_rtz4_27_26_25_23_22_21(uint64 instruction)
 }
 
 
-uint64 NMD::extract_sa_15_14_13_12_11(uint64 instruction)
+static uint64 extract_sa_15_14_13_12_11(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 11, 5);
@@ -947,7 +927,7 @@ uint64 NMD::extract_sa_15_14_13_12_11(uint64 instruction)
 }
 
 
-uint64 NMD::extract_shift_4_3_2_1_0(uint64 instruction)
+static uint64 extract_shift_4_3_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 5);
@@ -955,7 +935,7 @@ uint64 NMD::extract_shift_4_3_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_shiftx_10_9_8_7__s1(uint64 instruction)
+static uint64 extract_shiftx_10_9_8_7__s1(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 7, 4) << 1;
@@ -963,7 +943,7 @@ uint64 NMD::extract_shiftx_10_9_8_7__s1(uint64 instruction)
 }
 
 
-uint64 NMD::extract_hint_25_24_23_22_21(uint64 instruction)
+static uint64 extract_hint_25_24_23_22_21(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 21, 5);
@@ -971,7 +951,7 @@ uint64 NMD::extract_hint_25_24_23_22_21(uint64 instruction)
 }
 
 
-uint64 NMD::extract_count3_14_13_12(uint64 instruction)
+static uint64 extract_count3_14_13_12(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 12, 3);
@@ -979,7 +959,7 @@ uint64 NMD::extract_count3_14_13_12(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se31_0_11_to_2_20_to_12_s12(uint64 instruction)
+static int64 extract_s__se31_0_11_to_2_20_to_12_s12(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 0, 1) << 31;
@@ -990,7 +970,7 @@ int64 NMD::extract_s__se31_0_11_to_2_20_to_12_s12(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se7_0_6_5_4_3_2_1_s1(uint64 instruction)
+static int64 extract_s__se7_0_6_5_4_3_2_1_s1(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 0, 1) << 7;
@@ -1000,7 +980,7 @@ int64 NMD::extract_s__se7_0_6_5_4_3_2_1_s1(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u2_10_9(uint64 instruction)
+static uint64 extract_u2_10_9(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 9, 2);
@@ -1008,7 +988,7 @@ uint64 NMD::extract_u2_10_9(uint64 instruction)
 }
 
 
-uint64 NMD::extract_code_25_24_23_22_21_20_19_18_17_16(uint64 instruction)
+static uint64 extract_code_25_24_23_22_21_20_19_18_17_16(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 16, 10);
@@ -1016,7 +996,7 @@ uint64 NMD::extract_code_25_24_23_22_21_20_19_18_17_16(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rs_20_19_18_17_16(uint64 instruction)
+static uint64 extract_rs_20_19_18_17_16(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 16, 5);
@@ -1024,7 +1004,7 @@ uint64 NMD::extract_rs_20_19_18_17_16(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_2_1__s1(uint64 instruction)
+static uint64 extract_u_2_1__s1(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 1, 2) << 1;
@@ -1032,7 +1012,7 @@ uint64 NMD::extract_u_2_1__s1(uint64 instruction)
 }
 
 
-uint64 NMD::extract_stripe_6(uint64 instruction)
+static uint64 extract_stripe_6(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 6, 1);
@@ -1040,7 +1020,7 @@ uint64 NMD::extract_stripe_6(uint64 instruction)
 }
 
 
-uint64 NMD::extract_ac_15_14(uint64 instruction)
+static uint64 extract_ac_15_14(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 14, 2);
@@ -1048,7 +1028,7 @@ uint64 NMD::extract_ac_15_14(uint64 instruction)
 }
 
 
-uint64 NMD::extract_shift_20_19_18_17_16(uint64 instruction)
+static uint64 extract_shift_20_19_18_17_16(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 16, 5);
@@ -1056,7 +1036,7 @@ uint64 NMD::extract_shift_20_19_18_17_16(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rdl_25_24(uint64 instruction)
+static uint64 extract_rdl_25_24(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 24, 1);
@@ -1064,7 +1044,7 @@ uint64 NMD::extract_rdl_25_24(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(uint64 instruction)
+static int64 extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 0, 1) << 10;
@@ -1074,7 +1054,7 @@ int64 NMD::extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(uint64 instruction)
 }
 
 
-uint64 NMD::extract_eu_6_5_4_3_2_1_0(uint64 instruction)
+static uint64 extract_eu_6_5_4_3_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 7);
@@ -1082,7 +1062,7 @@ uint64 NMD::extract_eu_6_5_4_3_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_shift_5_4_3_2_1_0(uint64 instruction)
+static uint64 extract_shift_5_4_3_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 6);
@@ -1090,7 +1070,7 @@ uint64 NMD::extract_shift_5_4_3_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_count_19_18_17_16(uint64 instruction)
+static uint64 extract_count_19_18_17_16(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 16, 4);
@@ -1098,7 +1078,7 @@ uint64 NMD::extract_count_19_18_17_16(uint64 instruction)
 }
 
 
-uint64 NMD::extract_code_2_1_0(uint64 instruction)
+static uint64 extract_code_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 3);
@@ -1106,7 +1086,7 @@ uint64 NMD::extract_code_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3_2_1_0(uint64 instruction)
+static uint64 extract_u_11_10_9_8_7_6_5_4_3_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 12);
@@ -1114,7 +1094,7 @@ uint64 NMD::extract_u_11_10_9_8_7_6_5_4_3_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rs_4_3_2_1_0(uint64 instruction)
+static uint64 extract_rs_4_3_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 5);
@@ -1122,7 +1102,7 @@ uint64 NMD::extract_rs_4_3_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_20_to_3__s3(uint64 instruction)
+static uint64 extract_u_20_to_3__s3(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 3, 18) << 3;
@@ -1130,7 +1110,7 @@ uint64 NMD::extract_u_20_to_3__s3(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_3_2_1_0__s2(uint64 instruction)
+static uint64 extract_u_3_2_1_0__s2(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 4) << 2;
@@ -1138,7 +1118,7 @@ uint64 NMD::extract_u_3_2_1_0__s2(uint64 instruction)
 }
 
 
-uint64 NMD::extract_cofun_25_24_23(uint64 instruction)
+static uint64 extract_cofun_25_24_23(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 3, 23);
@@ -1146,7 +1126,7 @@ uint64 NMD::extract_cofun_25_24_23(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_2_1_0__s2(uint64 instruction)
+static uint64 extract_u_2_1_0__s2(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 3) << 2;
@@ -1154,7 +1134,7 @@ uint64 NMD::extract_u_2_1_0__s2(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rd3_3_2_1(uint64 instruction)
+static uint64 extract_rd3_3_2_1(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 1, 3);
@@ -1162,7 +1142,7 @@ uint64 NMD::extract_rd3_3_2_1(uint64 instruction)
 }
 
 
-uint64 NMD::extract_sa_15_14_13_12(uint64 instruction)
+static uint64 extract_sa_15_14_13_12(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 12, 4);
@@ -1170,7 +1150,7 @@ uint64 NMD::extract_sa_15_14_13_12(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rt_25_24_23_22_21(uint64 instruction)
+static uint64 extract_rt_25_24_23_22_21(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 21, 5);
@@ -1178,7 +1158,7 @@ uint64 NMD::extract_rt_25_24_23_22_21(uint64 instruction)
 }
 
 
-uint64 NMD::extract_ru_7_6_5_4_3(uint64 instruction)
+static uint64 extract_ru_7_6_5_4_3(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 3, 5);
@@ -1186,7 +1166,7 @@ uint64 NMD::extract_ru_7_6_5_4_3(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_17_to_0(uint64 instruction)
+static uint64 extract_u_17_to_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 18);
@@ -1194,7 +1174,7 @@ uint64 NMD::extract_u_17_to_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rsz4_4_2_1_0(uint64 instruction)
+static uint64 extract_rsz4_4_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 3);
@@ -1203,7 +1183,7 @@ uint64 NMD::extract_rsz4_4_2_1_0(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se21_0_20_to_1_s1(uint64 instruction)
+static int64 extract_s__se21_0_20_to_1_s1(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 0, 1) << 21;
@@ -1213,7 +1193,7 @@ int64 NMD::extract_s__se21_0_20_to_1_s1(uint64 instruction)
 }
 
 
-uint64 NMD::extract_op_25_to_3(uint64 instruction)
+static uint64 extract_op_25_to_3(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 3, 23);
@@ -1221,7 +1201,7 @@ uint64 NMD::extract_op_25_to_3(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rs4_4_2_1_0(uint64 instruction)
+static uint64 extract_rs4_4_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 3);
@@ -1230,7 +1210,7 @@ uint64 NMD::extract_rs4_4_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_bit_23_22_21(uint64 instruction)
+static uint64 extract_bit_23_22_21(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 21, 3);
@@ -1238,7 +1218,7 @@ uint64 NMD::extract_bit_23_22_21(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rt_41_40_39_38_37(uint64 instruction)
+static uint64 extract_rt_41_40_39_38_37(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 37, 5);
@@ -1246,7 +1226,7 @@ uint64 NMD::extract_rt_41_40_39_38_37(uint64 instruction)
 }
 
 
-int64 NMD::extract_shift__se5_21_20_19_18_17_16(uint64 instruction)
+static int64 extract_shift__se5_21_20_19_18_17_16(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 16, 6);
@@ -1255,7 +1235,7 @@ int64 NMD::extract_shift__se5_21_20_19_18_17_16(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rd2_3_8(uint64 instruction)
+static uint64 extract_rd2_3_8(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 3, 1) << 1;
@@ -1264,7 +1244,7 @@ uint64 NMD::extract_rd2_3_8(uint64 instruction)
 }
 
 
-uint64 NMD::extract_code_17_to_0(uint64 instruction)
+static uint64 extract_code_17_to_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 18);
@@ -1272,7 +1252,7 @@ uint64 NMD::extract_code_17_to_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_size_20_19_18_17_16(uint64 instruction)
+static uint64 extract_size_20_19_18_17_16(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 16, 5);
@@ -1280,7 +1260,7 @@ uint64 NMD::extract_size_20_19_18_17_16(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se8_15_7_6_5_4_3_2_s2(uint64 instruction)
+static int64 extract_s__se8_15_7_6_5_4_3_2_s2(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 2, 6) << 2;
@@ -1290,7 +1270,7 @@ int64 NMD::extract_s__se8_15_7_6_5_4_3_2_s2(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_15_to_0(uint64 instruction)
+static uint64 extract_u_15_to_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 16);
@@ -1298,7 +1278,7 @@ uint64 NMD::extract_u_15_to_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_fs_20_19_18_17_16(uint64 instruction)
+static uint64 extract_fs_20_19_18_17_16(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 16, 5);
@@ -1306,7 +1286,7 @@ uint64 NMD::extract_fs_20_19_18_17_16(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se8_15_7_6_5_4_3_2_1_0(uint64 instruction)
+static int64 extract_s__se8_15_7_6_5_4_3_2_1_0(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 0, 8);
@@ -1316,7 +1296,7 @@ int64 NMD::extract_s__se8_15_7_6_5_4_3_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_stype_20_19_18_17_16(uint64 instruction)
+static uint64 extract_stype_20_19_18_17_16(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 16, 5);
@@ -1324,7 +1304,7 @@ uint64 NMD::extract_stype_20_19_18_17_16(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rtl_11(uint64 instruction)
+static uint64 extract_rtl_11(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 9, 1);
@@ -1332,7 +1312,7 @@ uint64 NMD::extract_rtl_11(uint64 instruction)
 }
 
 
-uint64 NMD::extract_hs_20_19_18_17_16(uint64 instruction)
+static uint64 extract_hs_20_19_18_17_16(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 16, 5);
@@ -1340,7 +1320,7 @@ uint64 NMD::extract_hs_20_19_18_17_16(uint64 instruction)
 }
 
 
-uint64 NMD::extract_sel_13_12_11(uint64 instruction)
+static uint64 extract_sel_13_12_11(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 11, 3);
@@ -1348,7 +1328,7 @@ uint64 NMD::extract_sel_13_12_11(uint64 instruction)
 }
 
 
-uint64 NMD::extract_lsb_4_3_2_1_0(uint64 instruction)
+static uint64 extract_lsb_4_3_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 5);
@@ -1356,7 +1336,7 @@ uint64 NMD::extract_lsb_4_3_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_gp_2(uint64 instruction)
+static uint64 extract_gp_2(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 2, 1);
@@ -1364,7 +1344,7 @@ uint64 NMD::extract_gp_2(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rt3_9_8_7(uint64 instruction)
+static uint64 extract_rt3_9_8_7(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 7, 3);
@@ -1372,7 +1352,7 @@ uint64 NMD::extract_rt3_9_8_7(uint64 instruction)
 }
 
 
-uint64 NMD::extract_ft_25_24_23_22_21(uint64 instruction)
+static uint64 extract_ft_25_24_23_22_21(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 21, 5);
@@ -1380,7 +1360,7 @@ uint64 NMD::extract_ft_25_24_23_22_21(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_17_16_15_14_13_12_11(uint64 instruction)
+static uint64 extract_u_17_16_15_14_13_12_11(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 11, 7);
@@ -1388,7 +1368,7 @@ uint64 NMD::extract_u_17_16_15_14_13_12_11(uint64 instruction)
 }
 
 
-uint64 NMD::extract_cs_20_19_18_17_16(uint64 instruction)
+static uint64 extract_cs_20_19_18_17_16(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 16, 5);
@@ -1396,7 +1376,7 @@ uint64 NMD::extract_cs_20_19_18_17_16(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rt4_9_7_6_5(uint64 instruction)
+static uint64 extract_rt4_9_7_6_5(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 5, 3);
@@ -1405,7 +1385,7 @@ uint64 NMD::extract_rt4_9_7_6_5(uint64 instruction)
 }
 
 
-uint64 NMD::extract_msbt_10_9_8_7_6(uint64 instruction)
+static uint64 extract_msbt_10_9_8_7_6(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 6, 5);
@@ -1413,7 +1393,7 @@ uint64 NMD::extract_msbt_10_9_8_7_6(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_5_4_3_2_1_0__s2(uint64 instruction)
+static uint64 extract_u_5_4_3_2_1_0__s2(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 6) << 2;
@@ -1421,7 +1401,7 @@ uint64 NMD::extract_u_5_4_3_2_1_0__s2(uint64 instruction)
 }
 
 
-uint64 NMD::extract_sa_15_14_13(uint64 instruction)
+static uint64 extract_sa_15_14_13(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 13, 3);
@@ -1429,7 +1409,7 @@ uint64 NMD::extract_sa_15_14_13(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se14_0_13_to_1_s1(uint64 instruction)
+static int64 extract_s__se14_0_13_to_1_s1(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 0, 1) << 14;
@@ -1439,7 +1419,7 @@ int64 NMD::extract_s__se14_0_13_to_1_s1(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rs3_6_5_4(uint64 instruction)
+static uint64 extract_rs3_6_5_4(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 4, 3);
@@ -1447,7 +1427,7 @@ uint64 NMD::extract_rs3_6_5_4(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_31_to_0__s32(uint64 instruction)
+static uint64 extract_u_31_to_0__s32(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 32) << 32;
@@ -1455,7 +1435,7 @@ uint64 NMD::extract_u_31_to_0__s32(uint64 instruction)
 }
 
 
-uint64 NMD::extract_shift_10_9_8_7_6(uint64 instruction)
+static uint64 extract_shift_10_9_8_7_6(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 6, 5);
@@ -1463,7 +1443,7 @@ uint64 NMD::extract_shift_10_9_8_7_6(uint64 instruction)
 }
 
 
-uint64 NMD::extract_cs_25_24_23_22_21(uint64 instruction)
+static uint64 extract_cs_25_24_23_22_21(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 21, 5);
@@ -1471,7 +1451,7 @@ uint64 NMD::extract_cs_25_24_23_22_21(uint64 instruction)
 }
 
 
-uint64 NMD::extract_shiftx_11_10_9_8_7_6(uint64 instruction)
+static uint64 extract_shiftx_11_10_9_8_7_6(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 6, 6);
@@ -1479,7 +1459,7 @@ uint64 NMD::extract_shiftx_11_10_9_8_7_6(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rt_9_8_7_6_5(uint64 instruction)
+static uint64 extract_rt_9_8_7_6_5(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 5, 5);
@@ -1487,7 +1467,7 @@ uint64 NMD::extract_rt_9_8_7_6_5(uint64 instruction)
 }
 
 
-uint64 NMD::extract_op_25_24_23_22_21(uint64 instruction)
+static uint64 extract_op_25_24_23_22_21(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 21, 5);
@@ -1495,7 +1475,7 @@ uint64 NMD::extract_op_25_24_23_22_21(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_6_5_4_3_2_1_0__s2(uint64 instruction)
+static uint64 extract_u_6_5_4_3_2_1_0__s2(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 7) << 2;
@@ -1503,7 +1483,7 @@ uint64 NMD::extract_u_6_5_4_3_2_1_0__s2(uint64 instruction)
 }
 
 
-uint64 NMD::extract_bit_16_15_14_13_12_11(uint64 instruction)
+static uint64 extract_bit_16_15_14_13_12_11(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 11, 6);
@@ -1511,7 +1491,7 @@ uint64 NMD::extract_bit_16_15_14_13_12_11(uint64 instruction)
 }
 
 
-uint64 NMD::extract_mask_20_19_18_17_16_15_14(uint64 instruction)
+static uint64 extract_mask_20_19_18_17_16_15_14(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 14, 7);
@@ -1519,7 +1499,7 @@ uint64 NMD::extract_mask_20_19_18_17_16_15_14(uint64 instruction)
 }
 
 
-uint64 NMD::extract_eu_3_2_1_0(uint64 instruction)
+static uint64 extract_eu_3_2_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 4);
@@ -1527,7 +1507,7 @@ uint64 NMD::extract_eu_3_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_7_6_5_4__s4(uint64 instruction)
+static uint64 extract_u_7_6_5_4__s4(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 4, 4) << 4;
@@ -1535,7 +1515,7 @@ uint64 NMD::extract_u_7_6_5_4__s4(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se8_15_7_6_5_4_3_s3(uint64 instruction)
+static int64 extract_s__se8_15_7_6_5_4_3_s3(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 3, 5) << 3;
@@ -1545,7 +1525,7 @@ int64 NMD::extract_s__se8_15_7_6_5_4_3_s3(uint64 instruction)
 }
 
 
-uint64 NMD::extract_ft_15_14_13_12_11(uint64 instruction)
+static uint64 extract_ft_15_14_13_12_11(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 11, 5);
@@ -1553,7 +1533,7 @@ uint64 NMD::extract_ft_15_14_13_12_11(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se31_15_to_0_31_to_16(uint64 instruction)
+static int64 extract_s__se31_15_to_0_31_to_16(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 0, 16) << 16;
@@ -1563,7 +1543,7 @@ int64 NMD::extract_s__se31_15_to_0_31_to_16(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_20_19_18_17_16_15_14_13(uint64 instruction)
+static uint64 extract_u_20_19_18_17_16_15_14_13(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 13, 8);
@@ -1571,7 +1551,7 @@ uint64 NMD::extract_u_20_19_18_17_16_15_14_13(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_17_to_2__s2(uint64 instruction)
+static uint64 extract_u_17_to_2__s2(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 2, 16) << 2;
@@ -1579,7 +1559,7 @@ uint64 NMD::extract_u_17_to_2__s2(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rd_15_14_13_12_11(uint64 instruction)
+static uint64 extract_rd_15_14_13_12_11(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 11, 5);
@@ -1587,7 +1567,7 @@ uint64 NMD::extract_rd_15_14_13_12_11(uint64 instruction)
 }
 
 
-uint64 NMD::extract_c0s_20_19_18_17_16(uint64 instruction)
+static uint64 extract_c0s_20_19_18_17_16(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 16, 5);
@@ -1595,7 +1575,7 @@ uint64 NMD::extract_c0s_20_19_18_17_16(uint64 instruction)
 }
 
 
-uint64 NMD::extract_code_1_0(uint64 instruction)
+static uint64 extract_code_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 2);
@@ -1603,7 +1583,7 @@ uint64 NMD::extract_code_1_0(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se25_0_24_to_1_s1(uint64 instruction)
+static int64 extract_s__se25_0_24_to_1_s1(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 0, 1) << 25;
@@ -1613,7 +1593,7 @@ int64 NMD::extract_s__se25_0_24_to_1_s1(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_1_0(uint64 instruction)
+static uint64 extract_u_1_0(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 2);
@@ -1621,7 +1601,7 @@ uint64 NMD::extract_u_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_3_8__s2(uint64 instruction)
+static uint64 extract_u_3_8__s2(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 3, 1) << 3;
@@ -1630,7 +1610,7 @@ uint64 NMD::extract_u_3_8__s2(uint64 instruction)
 }
 
 
-uint64 NMD::extract_fd_15_14_13_12_11(uint64 instruction)
+static uint64 extract_fd_15_14_13_12_11(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 11, 5);
@@ -1638,7 +1618,7 @@ uint64 NMD::extract_fd_15_14_13_12_11(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_4_3_2_1_0__s2(uint64 instruction)
+static uint64 extract_u_4_3_2_1_0__s2(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 5) << 2;
@@ -1646,7 +1626,7 @@ uint64 NMD::extract_u_4_3_2_1_0__s2(uint64 instruction)
 }
 
 
-uint64 NMD::extract_rtz4_9_7_6_5(uint64 instruction)
+static uint64 extract_rtz4_9_7_6_5(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 5, 3);
@@ -1655,7 +1635,7 @@ uint64 NMD::extract_rtz4_9_7_6_5(uint64 instruction)
 }
 
 
-uint64 NMD::extract_sel_15_14_13_12_11(uint64 instruction)
+static uint64 extract_sel_15_14_13_12_11(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 11, 5);
@@ -1663,7 +1643,7 @@ uint64 NMD::extract_sel_15_14_13_12_11(uint64 instruction)
 }
 
 
-uint64 NMD::extract_ct_25_24_23_22_21(uint64 instruction)
+static uint64 extract_ct_25_24_23_22_21(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 21, 5);
@@ -1671,7 +1651,7 @@ uint64 NMD::extract_ct_25_24_23_22_21(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_20_to_2__s2(uint64 instruction)
+static uint64 extract_u_20_to_2__s2(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 2, 19) << 2;
@@ -1679,7 +1659,7 @@ uint64 NMD::extract_u_20_to_2__s2(uint64 instruction)
 }
 
 
-int64 NMD::extract_s__se3_4_2_1_0(uint64 instruction)
+static int64 extract_s__se3_4_2_1_0(uint64 instruction)
 {
     int64 value = 0;
     value |= extract_bits(instruction, 0, 3);
@@ -1689,7 +1669,7 @@ int64 NMD::extract_s__se3_4_2_1_0(uint64 instruction)
 }
 
 
-uint64 NMD::extract_u_3_2_1_0__s1(uint64 instruction)
+static uint64 extract_u_3_2_1_0__s1(uint64 instruction)
 {
     uint64 value = 0;
     value |= extract_bits(instruction, 0, 4) << 1;
diff --git a/disas/nanomips.h b/disas/nanomips.h
index 4f9ac4b9ab..c8a098922c 100644
--- a/disas/nanomips.h
+++ b/disas/nanomips.h
@@ -91,150 +91,6 @@ private:
                     TABLE_ENTRY_TYPE & type, const Pool *table,
                     int table_size, img_address m_pc);
 
-    uint64 renumber_registers(uint64 index, uint64 *register_list,
-                              size_t register_list_size);
-
-    uint64 decode_gpr_gpr4(uint64 d);
-    uint64 decode_gpr_gpr4_zero(uint64 d);
-    uint64 decode_gpr_gpr3(uint64 d);
-    uint64 decode_gpr_gpr3_src_store(uint64 d);
-    uint64 decode_gpr_gpr2_reg1(uint64 d);
-    uint64 decode_gpr_gpr2_reg2(uint64 d);
-    uint64 decode_gpr_gpr1(uint64 d);
-
-    uint64 copy(uint64 d);
-    int64 copy(int64 d);
-    int64 neg_copy(uint64 d);
-    int64 neg_copy(int64 d);
-    uint64 encode_rs3_and_check_rs3_ge_rt3(uint64 d);
-    uint64 encode_rs3_and_check_rs3_lt_rt3(uint64 d);
-    uint64 encode_s_from_address(uint64 d);
-    uint64 encode_u_from_address(uint64 d);
-    uint64 encode_s_from_s_hi(uint64 d);
-    uint64 encode_count3_from_count(uint64 d);
-    uint64 encode_shift3_from_shift(uint64 d);
-    int64 encode_eu_from_s_li16(uint64 d);
-    uint64 encode_msbd_from_size(uint64 d);
-    uint64 encode_eu_from_u_andi16(uint64 d);
-
-    uint64 encode_msbd_from_pos_and_size(uint64 d);
-
-    uint64 encode_rt1_from_rt(uint64 d);
-    uint64 encode_lsb_from_pos_and_size(uint64 d);
-
-    std::string save_restore_list(uint64 rt, uint64 count, uint64 gp);
-
-    std::string GPR(uint64 reg);
-    std::string FPR(uint64 reg);
-    std::string AC(uint64 reg);
-    std::string IMMEDIATE(uint64 value);
-    std::string IMMEDIATE(int64 value);
-    std::string CPR(uint64 reg);
-    std::string ADDRESS(uint64 value, int instruction_size, img_address m_pc);
-
-    int64 extract_s__se3_4_2_1_0(uint64 instruction);
-    int64 extract_s__se7_0_6_5_4_3_2_1_s1(uint64 instruction);
-    int64 extract_s__se8_15_7_6_5_4_3_s3(uint64 instruction);
-    int64 extract_s__se8_15_7_6_5_4_3_2_s2(uint64 instruction);
-    int64 extract_s__se8_15_7_6_5_4_3_2_1_0(uint64 instruction);
-    int64 extract_s__se9_20_19_18_17_16_15_14_13_12_11(uint64 instruction);
-    int64 extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(uint64 instruction);
-    int64 extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(uint64 instruction);
-    int64 extract_s__se14_0_13_to_1_s1(uint64 instruction);
-    int64 extract_s__se21_0_20_to_1_s1(uint64 instruction);
-    int64 extract_s__se25_0_24_to_1_s1(uint64 instruction);
-    int64 extract_s__se31_15_to_0_31_to_16(uint64 instruction);
-    int64 extract_s__se31_0_11_to_2_20_to_12_s12(uint64 instruction);
-    int64 extract_shift__se5_21_20_19_18_17_16(uint64 instruction);
-
-    uint64 extract_ac_15_14(uint64 instruction);
-    uint64 extract_bit_16_15_14_13_12_11(uint64 instruction);
-    uint64 extract_bit_23_22_21(uint64 instruction);
-    uint64 extract_c0s_20_19_18_17_16(uint64 instruction);
-    uint64 extract_code_17_to_0(uint64 instruction);
-    uint64 extract_code_18_to_0(uint64 instruction);
-    uint64 extract_code_1_0(uint64 instruction);
-    uint64 extract_code_2_1_0(uint64 instruction);
-    uint64 extract_code_25_24_23_22_21_20_19_18_17_16(uint64 instruction);
-    uint64 extract_cofun_25_24_23(uint64 instruction);
-    uint64 extract_count3_14_13_12(uint64 instruction);
-    uint64 extract_count_3_2_1_0(uint64 instruction);
-    uint64 extract_count_19_18_17_16(uint64 instruction);
-    uint64 extract_cs_20_19_18_17_16(uint64 instruction);
-    uint64 extract_cs_25_24_23_22_21(uint64 instruction);
-    uint64 extract_ct_25_24_23_22_21(uint64 instruction);
-    uint64 extract_eu_3_2_1_0(uint64 instruction);
-    uint64 extract_eu_6_5_4_3_2_1_0(uint64 instruction);
-    uint64 extract_fd_15_14_13_12_11(uint64 instruction);
-    uint64 extract_fs_20_19_18_17_16(uint64 instruction);
-    uint64 extract_ft_15_14_13_12_11(uint64 instruction);
-    uint64 extract_ft_25_24_23_22_21(uint64 instruction);
-    uint64 extract_gp_2(uint64 instruction);
-    uint64 extract_hint_25_24_23_22_21(uint64 instruction);
-    uint64 extract_hs_20_19_18_17_16(uint64 instruction);
-    uint64 extract_lsb_4_3_2_1_0(uint64 instruction);
-    uint64 extract_mask_20_19_18_17_16_15_14(uint64 instruction);
-    uint64 extract_msbt_10_9_8_7_6(uint64 instruction);
-    uint64 extract_op_25_24_23_22_21(uint64 instruction);
-    uint64 extract_op_25_to_3(uint64 instruction);
-    uint64 extract_rdl_25_24(uint64 instruction);
-    uint64 extract_rd2_3_8(uint64 instruction);
-    uint64 extract_rd3_3_2_1(uint64 instruction);
-    uint64 extract_rd_15_14_13_12_11(uint64 instruction);
-    uint64 extract_rs3_6_5_4(uint64 instruction);
-    uint64 extract_rs4_4_2_1_0(uint64 instruction);
-    uint64 extract_rs_4_3_2_1_0(uint64 instruction);
-    uint64 extract_rs_20_19_18_17_16(uint64 instruction);
-    uint64 extract_rsz4_4_2_1_0(uint64 instruction);
-    uint64 extract_rtl_11(uint64 instruction);
-    uint64 extract_rt3_9_8_7(uint64 instruction);
-    uint64 extract_rt4_9_7_6_5(uint64 instruction);
-    uint64 extract_rt_25_24_23_22_21(uint64 instruction);
-    uint64 extract_rt_41_40_39_38_37(uint64 instruction);
-    uint64 extract_rt_9_8_7_6_5(uint64 instruction);
-    uint64 extract_rtz3_9_8_7(uint64 instruction);
-    uint64 extract_rtz4_27_26_25_23_22_21(uint64 instruction);
-    uint64 extract_rtz4_9_7_6_5(uint64 instruction);
-    uint64 extract_ru_7_6_5_4_3(uint64 instruction);
-    uint64 extract_sa_15_14_13_12_11(uint64 instruction);
-    uint64 extract_sa_15_14_13_12(uint64 instruction);
-    uint64 extract_sa_15_14_13(uint64 instruction);
-    uint64 extract_sel_13_12_11(uint64 instruction);
-    uint64 extract_sel_15_14_13_12_11(uint64 instruction);
-    uint64 extract_shift3_2_1_0(uint64 instruction);
-    uint64 extract_shift_4_3_2_1_0(uint64 instruction);
-    uint64 extract_shift_5_4_3_2_1_0(uint64 instruction);
-    uint64 extract_shift_20_19_18_17_16(uint64 instruction);
-    uint64 extract_shift_10_9_8_7_6(uint64 instruction);
-    uint64 extract_shiftx_11_10_9_8_7_6(uint64 instruction);
-    uint64 extract_shiftx_10_9_8_7__s1(uint64 instruction);
-    uint64 extract_size_20_19_18_17_16(uint64 instruction);
-    uint64 extract_stripe_6(uint64 instruction);
-    uint64 extract_stype_20_19_18_17_16(uint64 instruction);
-    uint64 extract_u2_10_9(uint64 instruction);
-    uint64 extract_u_11_10_9_8_7_6_5_4_3_2_1_0(uint64 instruction);
-    uint64 extract_u_15_to_0(uint64 instruction);
-    uint64 extract_u_17_to_0(uint64 instruction);
-    uint64 extract_u_1_0(uint64 instruction);
-    uint64 extract_u_3_2_1_0__s1(uint64 instruction);
-    uint64 extract_u_2_1_0__s2(uint64 instruction);
-    uint64 extract_u_3_2_1_0__s2(uint64 instruction);
-    uint64 extract_u_4_3_2_1_0__s2(uint64 instruction);
-    uint64 extract_u_5_4_3_2_1_0__s2(uint64 instruction);
-    uint64 extract_u_6_5_4_3_2_1_0__s2(uint64 instruction);
-    uint64 extract_u_31_to_0__s32(uint64 instruction);
-    uint64 extract_u_10(uint64 instruction);
-    uint64 extract_u_17_16_15_14_13_12_11(uint64 instruction);
-    uint64 extract_u_20_19_18_17_16_15_14_13(uint64 instruction);
-    uint64 extract_u_17_to_1__s1(uint64 instruction);
-    uint64 extract_u_2_1__s1(uint64 instruction);
-    uint64 extract_u_17_to_2__s2(uint64 instruction);
-    uint64 extract_u_20_to_2__s2(uint64 instruction);
-    uint64 extract_u_20_to_3__s3(uint64 instruction);
-    uint64 extract_u_3_8__s2(uint64 instruction);
-    uint64 extract_u_11_10_9_8_7_6_5_4_3__s3(uint64 instruction);
-    uint64 extract_u_7_6_5_4__s4(uint64 instruction);
-
     bool ADDIU_32__cond(uint64 instruction);
     bool ADDIU_RS5__cond(uint64 instruction);
     bool BALRSC_cond(uint64 instruction);
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 04/20] disas/nanomips: Remove helper methods from class
  2022-09-05  9:55 ` [PATCH v2 04/20] disas/nanomips: Remove helper methods from class Milica Lazarevic
@ 2022-09-05 11:05   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:05 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> Helper methods from NMD class like NMD::renumber_registers,
> NMD::decode_gpr_gpr4... etc. are removed from the class. They're now
> declared global static functions.
> 
> Following helper methods have been deleted because they're not used by
> the nanomips disassembler:
> - NMD::encode_msbd_from_pos_and_size,
> - NMD::encode_s_from_s_hi,
> - NMD::neg_copy
> 
> Global functions used by those methods:
> - nanomips_dis
> - sign_extend
> - extract_bits
> have also been defined as static global functions.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> ---
>   disas/nanomips.cpp | 328 +++++++++++++++++++++------------------------
>   disas/nanomips.h   | 144 --------------------
>   2 files changed, 154 insertions(+), 318 deletions(-)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 05/20] disas/nanomips: Remove __cond methods from class
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (3 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 04/20] disas/nanomips: Remove helper methods from class Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:06   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 06/20] disas/nanomips: Remove disasm " Milica Lazarevic
                   ` (14 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic, Philippe Mathieu-Daudé

NMD class methods with the conditional_function type like
NMD::ADDIU_32__cond, NMD::ADDIU_RS5__cond, etc. are removed from the NMD
class. They're now declared global static functions. Therefore, typedef
of the function pointer, conditional_function is defined outside of the
class.

Now that conditional_function type functions are not part of the NMD
class we can't access them using the this pointer. Thus, the use of
the this pointer has been deleted.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
---
 disas/nanomips.cpp | 42 +++++++++++++++++++++---------------------
 disas/nanomips.h   | 14 ++------------
 2 files changed, 23 insertions(+), 33 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index 91ea35bf75..ecc3e7efda 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -781,7 +781,7 @@ int NMD::Disassemble(const uint16 * data, std::string & dis,
             if ((op_code & table[i].mask) == table[i].value) {
                 /* possible match */
                 conditional_function cond = table[i].condition;
-                if ((cond == 0) || (this->*cond)(op_code)) {
+                if ((cond == NULL) || cond(op_code)) {
                     try
                     {
                         if (table[i].type == pool) {
@@ -1678,28 +1678,28 @@ static uint64 extract_u_3_2_1_0__s1(uint64 instruction)
 
 
 
-bool NMD::ADDIU_32__cond(uint64 instruction)
+static bool ADDIU_32__cond(uint64 instruction)
 {
     uint64 rt = extract_rt_25_24_23_22_21(instruction);
     return rt != 0;
 }
 
 
-bool NMD::ADDIU_RS5__cond(uint64 instruction)
+static bool ADDIU_RS5__cond(uint64 instruction)
 {
     uint64 rt = extract_rt_9_8_7_6_5(instruction);
     return rt != 0;
 }
 
 
-bool NMD::BALRSC_cond(uint64 instruction)
+static bool BALRSC_cond(uint64 instruction)
 {
     uint64 rt = extract_rt_25_24_23_22_21(instruction);
     return rt != 0;
 }
 
 
-bool NMD::BEQC_16__cond(uint64 instruction)
+static bool BEQC_16__cond(uint64 instruction)
 {
     uint64 rs3 = extract_rs3_6_5_4(instruction);
     uint64 rt3 = extract_rt3_9_8_7(instruction);
@@ -1708,7 +1708,7 @@ bool NMD::BEQC_16__cond(uint64 instruction)
 }
 
 
-bool NMD::BNEC_16__cond(uint64 instruction)
+static bool BNEC_16__cond(uint64 instruction)
 {
     uint64 rs3 = extract_rs3_6_5_4(instruction);
     uint64 rt3 = extract_rt3_9_8_7(instruction);
@@ -1717,35 +1717,35 @@ bool NMD::BNEC_16__cond(uint64 instruction)
 }
 
 
-bool NMD::MOVE_cond(uint64 instruction)
+static bool MOVE_cond(uint64 instruction)
 {
     uint64 rt = extract_rt_9_8_7_6_5(instruction);
     return rt != 0;
 }
 
 
-bool NMD::P16_BR1_cond(uint64 instruction)
+static bool P16_BR1_cond(uint64 instruction)
 {
     uint64 u = extract_u_3_2_1_0__s1(instruction);
     return u != 0;
 }
 
 
-bool NMD::PREF_S9__cond(uint64 instruction)
+static bool PREF_S9__cond(uint64 instruction)
 {
     uint64 hint = extract_hint_25_24_23_22_21(instruction);
     return hint != 31;
 }
 
 
-bool NMD::PREFE_cond(uint64 instruction)
+static bool PREFE_cond(uint64 instruction)
 {
     uint64 hint = extract_hint_25_24_23_22_21(instruction);
     return hint != 31;
 }
 
 
-bool NMD::SLTU_cond(uint64 instruction)
+static bool SLTU_cond(uint64 instruction)
 {
     uint64 rd = extract_rd_15_14_13_12_11(instruction);
     return rd != 0;
@@ -16698,7 +16698,7 @@ NMD::Pool NMD::P_ADDIU[2] = {
        0xffe00000, 0x00000000, 0                      , 0,
        0x0                 },        /* P.RI */
     { instruction         , 0                   , 0   , 32,
-       0xfc000000, 0x00000000, &NMD::ADDIU_32_        , &NMD::ADDIU_32__cond   ,
+       0xfc000000, 0x00000000, &NMD::ADDIU_32_        , &ADDIU_32__cond   ,
        0x0                 },        /* ADDIU[32] */
 };
 
@@ -16796,7 +16796,7 @@ NMD::Pool NMD::P_SLTU[2] = {
        0xfc00fbff, 0x20000390, 0                      , 0,
        0x0                 },        /* P.DVP */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000390, &NMD::SLTU             , &NMD::SLTU_cond        ,
+       0xfc0003ff, 0x20000390, &NMD::SLTU             , &SLTU_cond        ,
        0x0                 },        /* SLTU */
 };
 
@@ -21341,7 +21341,7 @@ NMD::Pool NMD::P_PREF_S9_[2] = {
        0xffe07f00, 0xa7e01800, &NMD::SYNCI            , 0,
        0x0                 },        /* SYNCI */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4001800, &NMD::PREF_S9_         , &NMD::PREF_S9__cond    ,
+       0xfc007f00, 0xa4001800, &NMD::PREF_S9_         , &PREF_S9__cond    ,
        0x0                 },        /* PREF[S9] */
 };
 
@@ -21553,7 +21553,7 @@ NMD::Pool NMD::P_PREFE[2] = {
        0xffe07f00, 0xa7e01a00, &NMD::SYNCIE           , 0,
        CP0_ | EVA_         },        /* SYNCIE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4001a00, &NMD::PREFE            , &NMD::PREFE_cond       ,
+       0xfc007f00, 0xa4001a00, &NMD::PREFE            , &PREFE_cond       ,
        CP0_ | EVA_         },        /* PREFE */
 };
 
@@ -21725,7 +21725,7 @@ NMD::Pool NMD::P_BALRSC[2] = {
        0xffe0f000, 0x48008000, &NMD::BRSC             , 0,
        0x0                 },        /* BRSC */
     { call_instruction    , 0                   , 0   , 32,
-       0xfc00f000, 0x48008000, &NMD::BALRSC           , &NMD::BALRSC_cond      ,
+       0xfc00f000, 0x48008000, &NMD::BALRSC           , &BALRSC_cond      ,
        0x0                 },        /* BALRSC */
 };
 
@@ -22073,7 +22073,7 @@ NMD::Pool NMD::P16_MV[2] = {
        0xffe0    , 0x1000    , 0                      , 0,
        0x0                 },        /* P16.RI */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0x1000    , &NMD::MOVE             , &NMD::MOVE_cond        ,
+       0xfc00    , 0x1000    , &NMD::MOVE             , &MOVE_cond        ,
        0x0                 },        /* MOVE */
 };
 
@@ -22139,7 +22139,7 @@ NMD::Pool NMD::P_ADDIU_RS5_[2] = {
        0xffe8    , 0x9008    , &NMD::NOP_16_          , 0,
        0x0                 },        /* NOP[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc08    , 0x9008    , &NMD::ADDIU_RS5_       , &NMD::ADDIU_RS5__cond  ,
+       0xfc08    , 0x9008    , &NMD::ADDIU_RS5_       , &ADDIU_RS5__cond  ,
        0x0                 },        /* ADDIU[RS5] */
 };
 
@@ -22176,10 +22176,10 @@ NMD::Pool NMD::P16_JRC[2] = {
 
 NMD::Pool NMD::P16_BR1[2] = {
     { branch_instruction  , 0                   , 0   , 16,
-       0xfc00    , 0xd800    , &NMD::BEQC_16_         , &NMD::BEQC_16__cond    ,
+       0xfc00    , 0xd800    , &NMD::BEQC_16_         , &BEQC_16__cond    ,
        XMMS_               },        /* BEQC[16] */
     { branch_instruction  , 0                   , 0   , 16,
-       0xfc00    , 0xd800    , &NMD::BNEC_16_         , &NMD::BNEC_16__cond    ,
+       0xfc00    , 0xd800    , &NMD::BNEC_16_         , &BNEC_16__cond    ,
        XMMS_               },        /* BNEC[16] */
 };
 
@@ -22189,7 +22189,7 @@ NMD::Pool NMD::P16_BR[2] = {
        0xfc0f    , 0xd800    , 0                      , 0,
        0x0                 },        /* P16.JRC */
     { pool                , P16_BR1             , 2   , 16,
-       0xfc00    , 0xd800    , 0                      , &NMD::P16_BR1_cond     ,
+       0xfc00    , 0xd800    , 0                      , &P16_BR1_cond     ,
        0x0                 },        /* P16.BR1 */
 };
 
diff --git a/disas/nanomips.h b/disas/nanomips.h
index c8a098922c..ff91fbf8c6 100644
--- a/disas/nanomips.h
+++ b/disas/nanomips.h
@@ -31,6 +31,8 @@ typedef uint32_t uint32;
 typedef uint16_t uint16;
 typedef uint64_t img_address;
 
+typedef bool (*conditional_function)(uint64 instruction);
+
 enum TABLE_ENTRY_TYPE {
     instruction,
     call_instruction,
@@ -72,7 +74,6 @@ private:
 
     typedef std::string(NMD:: *disassembly_function)(uint64 instruction,
                                                      img_address m_pc);
-    typedef bool(NMD:: *conditional_function)(uint64 instruction);
 
     struct Pool {
         TABLE_ENTRY_TYPE     type;
@@ -91,17 +92,6 @@ private:
                     TABLE_ENTRY_TYPE & type, const Pool *table,
                     int table_size, img_address m_pc);
 
-    bool ADDIU_32__cond(uint64 instruction);
-    bool ADDIU_RS5__cond(uint64 instruction);
-    bool BALRSC_cond(uint64 instruction);
-    bool BEQC_16__cond(uint64 instruction);
-    bool BNEC_16__cond(uint64 instruction);
-    bool MOVE_cond(uint64 instruction);
-    bool P16_BR1_cond(uint64 instruction);
-    bool PREF_S9__cond(uint64 instruction);
-    bool PREFE_cond(uint64 instruction);
-    bool SLTU_cond(uint64 instruction);
-
     std::string ABS_D(uint64 instruction, img_address m_pc);
     std::string ABS_S(uint64 instruction, img_address m_pc);
     std::string ABSQ_S_PH(uint64 instruction, img_address m_pc);
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 05/20] disas/nanomips: Remove __cond methods from class
  2022-09-05  9:55 ` [PATCH v2 05/20] disas/nanomips: Remove __cond " Milica Lazarevic
@ 2022-09-05 11:06   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:06 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic,
	Philippe Mathieu-Daudé

On 9/5/22 10:55, Milica Lazarevic wrote:
> NMD class methods with the conditional_function type like
> NMD::ADDIU_32__cond, NMD::ADDIU_RS5__cond, etc. are removed from the NMD
> class. They're now declared global static functions. Therefore, typedef
> of the function pointer, conditional_function is defined outside of the
> class.
> 
> Now that conditional_function type functions are not part of the NMD
> class we can't access them using the this pointer. Thus, the use of
> the this pointer has been deleted.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> Reviewed-by: Philippe Mathieu-Daudé<f4bug@amsat.org>
> ---
>   disas/nanomips.cpp | 42 +++++++++++++++++++++---------------------
>   disas/nanomips.h   | 14 ++------------
>   2 files changed, 23 insertions(+), 33 deletions(-)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 06/20] disas/nanomips: Remove disasm methods from class
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (4 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 05/20] disas/nanomips: Remove __cond " Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:08   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 07/20] disas/nanomips: Remove Pool tables from the class Milica Lazarevic
                   ` (13 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic, Philippe Mathieu-Daudé

NMD class methods with the disassembly_function type like
NMD::ABS_D, NMD::ABS_S, etc. are removed from the class. They're now
declared global static functions. Therefore, typedef of the function
pointer, disassembly_function is defined outside of the class.

Now that disassembly_function type functions are not part of the NMD
class we can't access them using the this pointer. Thus, the use of
the this pointer has been deleted.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
---
 disas/nanomips.cpp | 2546 ++++++++++++++++++++++----------------------
 disas/nanomips.h   |  642 +----------
 2 files changed, 1275 insertions(+), 1913 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index ecc3e7efda..7ea6326f1d 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -808,7 +808,7 @@ int NMD::Disassemble(const uint16 * data, std::string & dis,
                                 return -6;
                             }
                             type = table[i].type;
-                            dis = (this->*dis_fn)(op_code, m_pc);
+                            dis = dis_fn(op_code, m_pc);
                             return table[i].instructions_size;
                         } else {
                             dis = "reserved instruction";
@@ -1763,7 +1763,7 @@ static bool SLTU_cond(uint64 instruction)
  *               fs -----
  *                    fd -----
  */
-std::string NMD::ABS_D(uint64 instruction, img_address m_pc)
+static std::string ABS_D(uint64 instruction, img_address m_pc)
 {
     uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -1785,7 +1785,7 @@ std::string NMD::ABS_D(uint64 instruction, img_address m_pc)
  *               fd -----
  *                    fs -----
  */
-std::string NMD::ABS_S(uint64 instruction, img_address m_pc)
+static std::string ABS_S(uint64 instruction, img_address m_pc)
 {
     uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -1807,7 +1807,7 @@ std::string NMD::ABS_S(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ABSQ_S_PH(uint64 instruction, img_address m_pc)
+static std::string ABSQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1829,7 +1829,7 @@ std::string NMD::ABSQ_S_PH(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ABSQ_S_QB(uint64 instruction, img_address m_pc)
+static std::string ABSQ_S_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1851,7 +1851,7 @@ std::string NMD::ABSQ_S_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ABSQ_S_W(uint64 instruction, img_address m_pc)
+static std::string ABSQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1872,7 +1872,7 @@ std::string NMD::ABSQ_S_W(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ACLR(uint64 instruction, img_address m_pc)
+static std::string ACLR(uint64 instruction, img_address m_pc)
 {
     uint64 bit_value = extract_bit_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1895,7 +1895,7 @@ std::string NMD::ACLR(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADD(uint64 instruction, img_address m_pc)
+static std::string ADD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1920,7 +1920,7 @@ std::string NMD::ADD(uint64 instruction, img_address m_pc)
  *               fs -----
  *                    fd -----
  */
-std::string NMD::ADD_D(uint64 instruction, img_address m_pc)
+static std::string ADD_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -1945,7 +1945,7 @@ std::string NMD::ADD_D(uint64 instruction, img_address m_pc)
  *               fs -----
  *                    fd -----
  */
-std::string NMD::ADD_S(uint64 instruction, img_address m_pc)
+static std::string ADD_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -1968,7 +1968,7 @@ std::string NMD::ADD_S(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_32_(uint64 instruction, img_address m_pc)
+static std::string ADDIU_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1991,7 +1991,7 @@ std::string NMD::ADDIU_32_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_48_(uint64 instruction, img_address m_pc)
+static std::string ADDIU_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -2012,7 +2012,7 @@ std::string NMD::ADDIU_48_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_GP48_(uint64 instruction, img_address m_pc)
+static std::string ADDIU_GP48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -2033,7 +2033,7 @@ std::string NMD::ADDIU_GP48_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_GP_B_(uint64 instruction, img_address m_pc)
+static std::string ADDIU_GP_B_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
@@ -2054,7 +2054,7 @@ std::string NMD::ADDIU_GP_B_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_GP_W_(uint64 instruction, img_address m_pc)
+static std::string ADDIU_GP_W_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
@@ -2075,7 +2075,7 @@ std::string NMD::ADDIU_GP_W_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_NEG_(uint64 instruction, img_address m_pc)
+static std::string ADDIU_NEG_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2098,7 +2098,7 @@ std::string NMD::ADDIU_NEG_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_R1_SP_(uint64 instruction, img_address m_pc)
+static std::string ADDIU_R1_SP_(uint64 instruction, img_address m_pc)
 {
     uint64 u_value = extract_u_5_4_3_2_1_0__s2(instruction);
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
@@ -2119,7 +2119,7 @@ std::string NMD::ADDIU_R1_SP_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::ADDIU_R2_(uint64 instruction, img_address m_pc)
+static std::string ADDIU_R2_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -2141,7 +2141,7 @@ std::string NMD::ADDIU_R2_(uint64 instruction, img_address m_pc)
  *     rt -----
  *           s - ---
  */
-std::string NMD::ADDIU_RS5_(uint64 instruction, img_address m_pc)
+static std::string ADDIU_RS5_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     int64 s_value = extract_s__se3_4_2_1_0(instruction);
@@ -2163,7 +2163,7 @@ std::string NMD::ADDIU_RS5_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDIUPC_32_(uint64 instruction, img_address m_pc)
+static std::string ADDIUPC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
@@ -2185,7 +2185,7 @@ std::string NMD::ADDIUPC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDIUPC_48_(uint64 instruction, img_address m_pc)
+static std::string ADDIUPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -2207,7 +2207,7 @@ std::string NMD::ADDIUPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQ_PH(uint64 instruction, img_address m_pc)
+static std::string ADDQ_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2232,7 +2232,7 @@ std::string NMD::ADDQ_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQ_S_PH(uint64 instruction, img_address m_pc)
+static std::string ADDQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2256,7 +2256,7 @@ std::string NMD::ADDQ_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQ_S_W(uint64 instruction, img_address m_pc)
+static std::string ADDQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2281,7 +2281,7 @@ std::string NMD::ADDQ_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQH_PH(uint64 instruction, img_address m_pc)
+static std::string ADDQH_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2306,7 +2306,7 @@ std::string NMD::ADDQH_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQH_R_PH(uint64 instruction, img_address m_pc)
+static std::string ADDQH_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2331,7 +2331,7 @@ std::string NMD::ADDQH_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQH_R_W(uint64 instruction, img_address m_pc)
+static std::string ADDQH_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2356,7 +2356,7 @@ std::string NMD::ADDQH_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDQH_W(uint64 instruction, img_address m_pc)
+static std::string ADDQH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2380,7 +2380,7 @@ std::string NMD::ADDQH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDSC(uint64 instruction, img_address m_pc)
+static std::string ADDSC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2403,7 +2403,7 @@ std::string NMD::ADDSC(uint64 instruction, img_address m_pc)
  *       rs3 ---
  *          rd3 ---
  */
-std::string NMD::ADDU_16_(uint64 instruction, img_address m_pc)
+static std::string ADDU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -2427,7 +2427,7 @@ std::string NMD::ADDU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_32_(uint64 instruction, img_address m_pc)
+static std::string ADDU_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2451,7 +2451,7 @@ std::string NMD::ADDU_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_4X4_(uint64 instruction, img_address m_pc)
+static std::string ADDU_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
@@ -2473,7 +2473,7 @@ std::string NMD::ADDU_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_PH(uint64 instruction, img_address m_pc)
+static std::string ADDU_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2497,7 +2497,7 @@ std::string NMD::ADDU_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_QB(uint64 instruction, img_address m_pc)
+static std::string ADDU_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2522,7 +2522,7 @@ std::string NMD::ADDU_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_S_PH(uint64 instruction, img_address m_pc)
+static std::string ADDU_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2546,7 +2546,7 @@ std::string NMD::ADDU_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDU_S_QB(uint64 instruction, img_address m_pc)
+static std::string ADDU_S_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2571,7 +2571,7 @@ std::string NMD::ADDU_S_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDUH_QB(uint64 instruction, img_address m_pc)
+static std::string ADDUH_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2596,7 +2596,7 @@ std::string NMD::ADDUH_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDUH_R_QB(uint64 instruction, img_address m_pc)
+static std::string ADDUH_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2619,7 +2619,7 @@ std::string NMD::ADDUH_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ADDWC(uint64 instruction, img_address m_pc)
+static std::string ADDWC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2643,7 +2643,7 @@ std::string NMD::ADDWC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ALUIPC(uint64 instruction, img_address m_pc)
+static std::string ALUIPC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
@@ -2664,7 +2664,7 @@ std::string NMD::ALUIPC(uint64 instruction, img_address m_pc)
  *       rs3 ---
  *           eu ----
  */
-std::string NMD::AND_16_(uint64 instruction, img_address m_pc)
+static std::string AND_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -2686,7 +2686,7 @@ std::string NMD::AND_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::AND_32_(uint64 instruction, img_address m_pc)
+static std::string AND_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2709,7 +2709,7 @@ std::string NMD::AND_32_(uint64 instruction, img_address m_pc)
  *       rs3 ---
  *           eu ----
  */
-std::string NMD::ANDI_16_(uint64 instruction, img_address m_pc)
+static std::string ANDI_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -2733,7 +2733,7 @@ std::string NMD::ANDI_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ANDI_32_(uint64 instruction, img_address m_pc)
+static std::string ANDI_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2757,7 +2757,7 @@ std::string NMD::ANDI_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::APPEND(uint64 instruction, img_address m_pc)
+static std::string APPEND(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2781,7 +2781,7 @@ std::string NMD::APPEND(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ASET(uint64 instruction, img_address m_pc)
+static std::string ASET(uint64 instruction, img_address m_pc)
 {
     uint64 bit_value = extract_bit_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2805,7 +2805,7 @@ std::string NMD::ASET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BALC_16_(uint64 instruction, img_address m_pc)
+static std::string BALC_16_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
 
@@ -2825,7 +2825,7 @@ std::string NMD::BALC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BALC_32_(uint64 instruction, img_address m_pc)
+static std::string BALC_32_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
 
@@ -2845,7 +2845,7 @@ std::string NMD::BALC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BALRSC(uint64 instruction, img_address m_pc)
+static std::string BALRSC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2867,7 +2867,7 @@ std::string NMD::BALRSC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BBEQZC(uint64 instruction, img_address m_pc)
+static std::string BBEQZC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
@@ -2891,7 +2891,7 @@ std::string NMD::BBEQZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BBNEZC(uint64 instruction, img_address m_pc)
+static std::string BBNEZC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
@@ -2915,7 +2915,7 @@ std::string NMD::BBNEZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC_16_(uint64 instruction, img_address m_pc)
+static std::string BC_16_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
 
@@ -2935,7 +2935,7 @@ std::string NMD::BC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC_32_(uint64 instruction, img_address m_pc)
+static std::string BC_32_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
 
@@ -2955,7 +2955,7 @@ std::string NMD::BC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC1EQZC(uint64 instruction, img_address m_pc)
+static std::string BC1EQZC(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
@@ -2977,7 +2977,7 @@ std::string NMD::BC1EQZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC1NEZC(uint64 instruction, img_address m_pc)
+static std::string BC1NEZC(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
@@ -2999,7 +2999,7 @@ std::string NMD::BC1NEZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC2EQZC(uint64 instruction, img_address m_pc)
+static std::string BC2EQZC(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
@@ -3021,7 +3021,7 @@ std::string NMD::BC2EQZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BC2NEZC(uint64 instruction, img_address m_pc)
+static std::string BC2NEZC(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
@@ -3043,7 +3043,7 @@ std::string NMD::BC2NEZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BEQC_16_(uint64 instruction, img_address m_pc)
+static std::string BEQC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -3067,7 +3067,7 @@ std::string NMD::BEQC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BEQC_32_(uint64 instruction, img_address m_pc)
+static std::string BEQC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3091,7 +3091,7 @@ std::string NMD::BEQC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BEQIC(uint64 instruction, img_address m_pc)
+static std::string BEQIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3115,7 +3115,7 @@ std::string NMD::BEQIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BEQZC_16_(uint64 instruction, img_address m_pc)
+static std::string BEQZC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
@@ -3137,7 +3137,7 @@ std::string NMD::BEQZC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BGEC(uint64 instruction, img_address m_pc)
+static std::string BGEC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3161,7 +3161,7 @@ std::string NMD::BGEC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BGEIC(uint64 instruction, img_address m_pc)
+static std::string BGEIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3185,7 +3185,7 @@ std::string NMD::BGEIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BGEIUC(uint64 instruction, img_address m_pc)
+static std::string BGEIUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3209,7 +3209,7 @@ std::string NMD::BGEIUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BGEUC(uint64 instruction, img_address m_pc)
+static std::string BGEUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3233,7 +3233,7 @@ std::string NMD::BGEUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BLTC(uint64 instruction, img_address m_pc)
+static std::string BLTC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3257,7 +3257,7 @@ std::string NMD::BLTC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BLTIC(uint64 instruction, img_address m_pc)
+static std::string BLTIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3281,7 +3281,7 @@ std::string NMD::BLTIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BLTIUC(uint64 instruction, img_address m_pc)
+static std::string BLTIUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3305,7 +3305,7 @@ std::string NMD::BLTIUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BLTUC(uint64 instruction, img_address m_pc)
+static std::string BLTUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3329,7 +3329,7 @@ std::string NMD::BLTUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BNEC_16_(uint64 instruction, img_address m_pc)
+static std::string BNEC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -3353,7 +3353,7 @@ std::string NMD::BNEC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BNEC_32_(uint64 instruction, img_address m_pc)
+static std::string BNEC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3377,7 +3377,7 @@ std::string NMD::BNEC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BNEIC(uint64 instruction, img_address m_pc)
+static std::string BNEIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
@@ -3401,7 +3401,7 @@ std::string NMD::BNEIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BNEZC_16_(uint64 instruction, img_address m_pc)
+static std::string BNEZC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
@@ -3423,7 +3423,7 @@ std::string NMD::BNEZC_16_(uint64 instruction, img_address m_pc)
  *            s[13:1] -------------
  *                           s[14] -
  */
-std::string NMD::BPOSGE32C(uint64 instruction, img_address m_pc)
+static std::string BPOSGE32C(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
@@ -3443,7 +3443,7 @@ std::string NMD::BPOSGE32C(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BREAK_16_(uint64 instruction, img_address m_pc)
+static std::string BREAK_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
@@ -3463,7 +3463,7 @@ std::string NMD::BREAK_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BREAK_32_(uint64 instruction, img_address m_pc)
+static std::string BREAK_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
@@ -3483,7 +3483,7 @@ std::string NMD::BREAK_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::BRSC(uint64 instruction, img_address m_pc)
+static std::string BRSC(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
@@ -3503,7 +3503,7 @@ std::string NMD::BRSC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CACHE(uint64 instruction, img_address m_pc)
+static std::string CACHE(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3527,7 +3527,7 @@ std::string NMD::CACHE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CACHEE(uint64 instruction, img_address m_pc)
+static std::string CACHEE(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3551,7 +3551,7 @@ std::string NMD::CACHEE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CEIL_L_D(uint64 instruction, img_address m_pc)
+static std::string CEIL_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3573,7 +3573,7 @@ std::string NMD::CEIL_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CEIL_L_S(uint64 instruction, img_address m_pc)
+static std::string CEIL_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3595,7 +3595,7 @@ std::string NMD::CEIL_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CEIL_W_D(uint64 instruction, img_address m_pc)
+static std::string CEIL_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3617,7 +3617,7 @@ std::string NMD::CEIL_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CEIL_W_S(uint64 instruction, img_address m_pc)
+static std::string CEIL_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3639,7 +3639,7 @@ std::string NMD::CEIL_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CFC1(uint64 instruction, img_address m_pc)
+static std::string CFC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -3661,7 +3661,7 @@ std::string NMD::CFC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CFC2(uint64 instruction, img_address m_pc)
+static std::string CFC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -3683,7 +3683,7 @@ std::string NMD::CFC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CLASS_D(uint64 instruction, img_address m_pc)
+static std::string CLASS_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3705,7 +3705,7 @@ std::string NMD::CLASS_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CLASS_S(uint64 instruction, img_address m_pc)
+static std::string CLASS_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3727,7 +3727,7 @@ std::string NMD::CLASS_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CLO(uint64 instruction, img_address m_pc)
+static std::string CLO(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3749,7 +3749,7 @@ std::string NMD::CLO(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CLZ(uint64 instruction, img_address m_pc)
+static std::string CLZ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3771,7 +3771,7 @@ std::string NMD::CLZ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_AF_D(uint64 instruction, img_address m_pc)
+static std::string CMP_AF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3795,7 +3795,7 @@ std::string NMD::CMP_AF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_AF_S(uint64 instruction, img_address m_pc)
+static std::string CMP_AF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3819,7 +3819,7 @@ std::string NMD::CMP_AF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_EQ_D(uint64 instruction, img_address m_pc)
+static std::string CMP_EQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3842,7 +3842,7 @@ std::string NMD::CMP_EQ_D(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMP_EQ_PH(uint64 instruction, img_address m_pc)
+static std::string CMP_EQ_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3864,7 +3864,7 @@ std::string NMD::CMP_EQ_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_EQ_S(uint64 instruction, img_address m_pc)
+static std::string CMP_EQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3888,7 +3888,7 @@ std::string NMD::CMP_EQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_LE_D(uint64 instruction, img_address m_pc)
+static std::string CMP_LE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3911,7 +3911,7 @@ std::string NMD::CMP_LE_D(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMP_LE_PH(uint64 instruction, img_address m_pc)
+static std::string CMP_LE_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3933,7 +3933,7 @@ std::string NMD::CMP_LE_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_LE_S(uint64 instruction, img_address m_pc)
+static std::string CMP_LE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3957,7 +3957,7 @@ std::string NMD::CMP_LE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_LT_D(uint64 instruction, img_address m_pc)
+static std::string CMP_LT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -3980,7 +3980,7 @@ std::string NMD::CMP_LT_D(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMP_LT_PH(uint64 instruction, img_address m_pc)
+static std::string CMP_LT_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -4002,7 +4002,7 @@ std::string NMD::CMP_LT_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_LT_S(uint64 instruction, img_address m_pc)
+static std::string CMP_LT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4026,7 +4026,7 @@ std::string NMD::CMP_LT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_NE_D(uint64 instruction, img_address m_pc)
+static std::string CMP_NE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4050,7 +4050,7 @@ std::string NMD::CMP_NE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_NE_S(uint64 instruction, img_address m_pc)
+static std::string CMP_NE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4074,7 +4074,7 @@ std::string NMD::CMP_NE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_OR_D(uint64 instruction, img_address m_pc)
+static std::string CMP_OR_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4098,7 +4098,7 @@ std::string NMD::CMP_OR_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_OR_S(uint64 instruction, img_address m_pc)
+static std::string CMP_OR_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4122,7 +4122,7 @@ std::string NMD::CMP_OR_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SAF_D(uint64 instruction, img_address m_pc)
+static std::string CMP_SAF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4146,7 +4146,7 @@ std::string NMD::CMP_SAF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SAF_S(uint64 instruction, img_address m_pc)
+static std::string CMP_SAF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4170,7 +4170,7 @@ std::string NMD::CMP_SAF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SEQ_D(uint64 instruction, img_address m_pc)
+static std::string CMP_SEQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4194,7 +4194,7 @@ std::string NMD::CMP_SEQ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SEQ_S(uint64 instruction, img_address m_pc)
+static std::string CMP_SEQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4218,7 +4218,7 @@ std::string NMD::CMP_SEQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SLE_D(uint64 instruction, img_address m_pc)
+static std::string CMP_SLE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4242,7 +4242,7 @@ std::string NMD::CMP_SLE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SLE_S(uint64 instruction, img_address m_pc)
+static std::string CMP_SLE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4266,7 +4266,7 @@ std::string NMD::CMP_SLE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SLT_D(uint64 instruction, img_address m_pc)
+static std::string CMP_SLT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4290,7 +4290,7 @@ std::string NMD::CMP_SLT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SLT_S(uint64 instruction, img_address m_pc)
+static std::string CMP_SLT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4314,7 +4314,7 @@ std::string NMD::CMP_SLT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SNE_D(uint64 instruction, img_address m_pc)
+static std::string CMP_SNE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4338,7 +4338,7 @@ std::string NMD::CMP_SNE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SNE_S(uint64 instruction, img_address m_pc)
+static std::string CMP_SNE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4362,7 +4362,7 @@ std::string NMD::CMP_SNE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SOR_D(uint64 instruction, img_address m_pc)
+static std::string CMP_SOR_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4386,7 +4386,7 @@ std::string NMD::CMP_SOR_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SOR_S(uint64 instruction, img_address m_pc)
+static std::string CMP_SOR_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4410,7 +4410,7 @@ std::string NMD::CMP_SOR_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUEQ_D(uint64 instruction, img_address m_pc)
+static std::string CMP_SUEQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4434,7 +4434,7 @@ std::string NMD::CMP_SUEQ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUEQ_S(uint64 instruction, img_address m_pc)
+static std::string CMP_SUEQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4458,7 +4458,7 @@ std::string NMD::CMP_SUEQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SULE_D(uint64 instruction, img_address m_pc)
+static std::string CMP_SULE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4482,7 +4482,7 @@ std::string NMD::CMP_SULE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SULE_S(uint64 instruction, img_address m_pc)
+static std::string CMP_SULE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4506,7 +4506,7 @@ std::string NMD::CMP_SULE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SULT_D(uint64 instruction, img_address m_pc)
+static std::string CMP_SULT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4530,7 +4530,7 @@ std::string NMD::CMP_SULT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SULT_S(uint64 instruction, img_address m_pc)
+static std::string CMP_SULT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4554,7 +4554,7 @@ std::string NMD::CMP_SULT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUN_D(uint64 instruction, img_address m_pc)
+static std::string CMP_SUN_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4578,7 +4578,7 @@ std::string NMD::CMP_SUN_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUNE_D(uint64 instruction, img_address m_pc)
+static std::string CMP_SUNE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4602,7 +4602,7 @@ std::string NMD::CMP_SUNE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUNE_S(uint64 instruction, img_address m_pc)
+static std::string CMP_SUNE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4626,7 +4626,7 @@ std::string NMD::CMP_SUNE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_SUN_S(uint64 instruction, img_address m_pc)
+static std::string CMP_SUN_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4650,7 +4650,7 @@ std::string NMD::CMP_SUN_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UEQ_D(uint64 instruction, img_address m_pc)
+static std::string CMP_UEQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4674,7 +4674,7 @@ std::string NMD::CMP_UEQ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UEQ_S(uint64 instruction, img_address m_pc)
+static std::string CMP_UEQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4698,7 +4698,7 @@ std::string NMD::CMP_UEQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_ULE_D(uint64 instruction, img_address m_pc)
+static std::string CMP_ULE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4722,7 +4722,7 @@ std::string NMD::CMP_ULE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_ULE_S(uint64 instruction, img_address m_pc)
+static std::string CMP_ULE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4746,7 +4746,7 @@ std::string NMD::CMP_ULE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_ULT_D(uint64 instruction, img_address m_pc)
+static std::string CMP_ULT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4770,7 +4770,7 @@ std::string NMD::CMP_ULT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_ULT_S(uint64 instruction, img_address m_pc)
+static std::string CMP_ULT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4794,7 +4794,7 @@ std::string NMD::CMP_ULT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UN_D(uint64 instruction, img_address m_pc)
+static std::string CMP_UN_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4818,7 +4818,7 @@ std::string NMD::CMP_UN_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UNE_D(uint64 instruction, img_address m_pc)
+static std::string CMP_UNE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4842,7 +4842,7 @@ std::string NMD::CMP_UNE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UNE_S(uint64 instruction, img_address m_pc)
+static std::string CMP_UNE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4866,7 +4866,7 @@ std::string NMD::CMP_UNE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMP_UN_S(uint64 instruction, img_address m_pc)
+static std::string CMP_UN_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -4891,7 +4891,7 @@ std::string NMD::CMP_UN_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGDU_EQ_QB(uint64 instruction, img_address m_pc)
+static std::string CMPGDU_EQ_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -4916,7 +4916,7 @@ std::string NMD::CMPGDU_EQ_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGDU_LE_QB(uint64 instruction, img_address m_pc)
+static std::string CMPGDU_LE_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -4941,7 +4941,7 @@ std::string NMD::CMPGDU_LE_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGDU_LT_QB(uint64 instruction, img_address m_pc)
+static std::string CMPGDU_LT_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -4966,7 +4966,7 @@ std::string NMD::CMPGDU_LT_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGU_EQ_QB(uint64 instruction, img_address m_pc)
+static std::string CMPGU_EQ_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -4991,7 +4991,7 @@ std::string NMD::CMPGU_EQ_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGU_LE_QB(uint64 instruction, img_address m_pc)
+static std::string CMPGU_LE_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5016,7 +5016,7 @@ std::string NMD::CMPGU_LE_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CMPGU_LT_QB(uint64 instruction, img_address m_pc)
+static std::string CMPGU_LT_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5040,7 +5040,7 @@ std::string NMD::CMPGU_LT_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMPU_EQ_QB(uint64 instruction, img_address m_pc)
+static std::string CMPU_EQ_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5062,7 +5062,7 @@ std::string NMD::CMPU_EQ_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMPU_LE_QB(uint64 instruction, img_address m_pc)
+static std::string CMPU_LE_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5084,7 +5084,7 @@ std::string NMD::CMPU_LE_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::CMPU_LT_QB(uint64 instruction, img_address m_pc)
+static std::string CMPU_LT_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5106,7 +5106,7 @@ std::string NMD::CMPU_LT_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::COP2_1(uint64 instruction, img_address m_pc)
+static std::string COP2_1(uint64 instruction, img_address m_pc)
 {
     uint64 cofun_value = extract_cofun_25_24_23(instruction);
 
@@ -5126,7 +5126,7 @@ std::string NMD::COP2_1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CTC1(uint64 instruction, img_address m_pc)
+static std::string CTC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -5148,7 +5148,7 @@ std::string NMD::CTC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CTC2(uint64 instruction, img_address m_pc)
+static std::string CTC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -5170,7 +5170,7 @@ std::string NMD::CTC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_D_L(uint64 instruction, img_address m_pc)
+static std::string CVT_D_L(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5192,7 +5192,7 @@ std::string NMD::CVT_D_L(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_D_S(uint64 instruction, img_address m_pc)
+static std::string CVT_D_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5214,7 +5214,7 @@ std::string NMD::CVT_D_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_D_W(uint64 instruction, img_address m_pc)
+static std::string CVT_D_W(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5236,7 +5236,7 @@ std::string NMD::CVT_D_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_L_D(uint64 instruction, img_address m_pc)
+static std::string CVT_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5258,7 +5258,7 @@ std::string NMD::CVT_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_L_S(uint64 instruction, img_address m_pc)
+static std::string CVT_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5280,7 +5280,7 @@ std::string NMD::CVT_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_S_D(uint64 instruction, img_address m_pc)
+static std::string CVT_S_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5302,7 +5302,7 @@ std::string NMD::CVT_S_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_S_L(uint64 instruction, img_address m_pc)
+static std::string CVT_S_L(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5324,7 +5324,7 @@ std::string NMD::CVT_S_L(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_S_PL(uint64 instruction, img_address m_pc)
+static std::string CVT_S_PL(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5346,7 +5346,7 @@ std::string NMD::CVT_S_PL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_S_PU(uint64 instruction, img_address m_pc)
+static std::string CVT_S_PU(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5368,7 +5368,7 @@ std::string NMD::CVT_S_PU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_S_W(uint64 instruction, img_address m_pc)
+static std::string CVT_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5390,7 +5390,7 @@ std::string NMD::CVT_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_W_D(uint64 instruction, img_address m_pc)
+static std::string CVT_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5412,7 +5412,7 @@ std::string NMD::CVT_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::CVT_W_S(uint64 instruction, img_address m_pc)
+static std::string CVT_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5434,7 +5434,7 @@ std::string NMD::CVT_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DADDIU_48_(uint64 instruction, img_address m_pc)
+static std::string DADDIU_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -5456,7 +5456,7 @@ std::string NMD::DADDIU_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DADDIU_NEG_(uint64 instruction, img_address m_pc)
+static std::string DADDIU_NEG_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5480,7 +5480,7 @@ std::string NMD::DADDIU_NEG_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DADDIU_U12_(uint64 instruction, img_address m_pc)
+static std::string DADDIU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5504,7 +5504,7 @@ std::string NMD::DADDIU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DADD(uint64 instruction, img_address m_pc)
+static std::string DADD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5528,7 +5528,7 @@ std::string NMD::DADD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DADDU(uint64 instruction, img_address m_pc)
+static std::string DADDU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5552,7 +5552,7 @@ std::string NMD::DADDU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DCLO(uint64 instruction, img_address m_pc)
+static std::string DCLO(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5574,7 +5574,7 @@ std::string NMD::DCLO(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DCLZ(uint64 instruction, img_address m_pc)
+static std::string DCLZ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5596,7 +5596,7 @@ std::string NMD::DCLZ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DDIV(uint64 instruction, img_address m_pc)
+static std::string DDIV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5620,7 +5620,7 @@ std::string NMD::DDIV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DDIVU(uint64 instruction, img_address m_pc)
+static std::string DDIVU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5644,7 +5644,7 @@ std::string NMD::DDIVU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DERET(uint64 instruction, img_address m_pc)
+static std::string DERET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -5662,7 +5662,7 @@ std::string NMD::DERET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DEXTM(uint64 instruction, img_address m_pc)
+static std::string DEXTM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5688,7 +5688,7 @@ std::string NMD::DEXTM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DEXT(uint64 instruction, img_address m_pc)
+static std::string DEXT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5714,7 +5714,7 @@ std::string NMD::DEXT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DEXTU(uint64 instruction, img_address m_pc)
+static std::string DEXTU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5740,7 +5740,7 @@ std::string NMD::DEXTU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DINSM(uint64 instruction, img_address m_pc)
+static std::string DINSM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5768,7 +5768,7 @@ std::string NMD::DINSM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DINS(uint64 instruction, img_address m_pc)
+static std::string DINS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5796,7 +5796,7 @@ std::string NMD::DINS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DINSU(uint64 instruction, img_address m_pc)
+static std::string DINSU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5824,7 +5824,7 @@ std::string NMD::DINSU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DI(uint64 instruction, img_address m_pc)
+static std::string DI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -5844,7 +5844,7 @@ std::string NMD::DI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DIV(uint64 instruction, img_address m_pc)
+static std::string DIV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5868,7 +5868,7 @@ std::string NMD::DIV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DIV_D(uint64 instruction, img_address m_pc)
+static std::string DIV_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5892,7 +5892,7 @@ std::string NMD::DIV_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DIV_S(uint64 instruction, img_address m_pc)
+static std::string DIV_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -5916,7 +5916,7 @@ std::string NMD::DIV_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DIVU(uint64 instruction, img_address m_pc)
+static std::string DIVU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5940,7 +5940,7 @@ std::string NMD::DIVU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DLSA(uint64 instruction, img_address m_pc)
+static std::string DLSA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -5966,7 +5966,7 @@ std::string NMD::DLSA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DLUI_48_(uint64 instruction, img_address m_pc)
+static std::string DLUI_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     uint64 u_value = extract_u_31_to_0__s32(instruction);
@@ -5988,7 +5988,7 @@ std::string NMD::DLUI_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMFC0(uint64 instruction, img_address m_pc)
+static std::string DMFC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -6012,7 +6012,7 @@ std::string NMD::DMFC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMFC1(uint64 instruction, img_address m_pc)
+static std::string DMFC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -6034,7 +6034,7 @@ std::string NMD::DMFC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMFC2(uint64 instruction, img_address m_pc)
+static std::string DMFC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -6056,7 +6056,7 @@ std::string NMD::DMFC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMFGC0(uint64 instruction, img_address m_pc)
+static std::string DMFGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -6080,7 +6080,7 @@ std::string NMD::DMFGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMOD(uint64 instruction, img_address m_pc)
+static std::string DMOD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6104,7 +6104,7 @@ std::string NMD::DMOD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMODU(uint64 instruction, img_address m_pc)
+static std::string DMODU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6128,7 +6128,7 @@ std::string NMD::DMODU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMTC0(uint64 instruction, img_address m_pc)
+static std::string DMTC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -6152,7 +6152,7 @@ std::string NMD::DMTC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMTC1(uint64 instruction, img_address m_pc)
+static std::string DMTC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -6174,7 +6174,7 @@ std::string NMD::DMTC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMTC2(uint64 instruction, img_address m_pc)
+static std::string DMTC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -6196,7 +6196,7 @@ std::string NMD::DMTC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMTGC0(uint64 instruction, img_address m_pc)
+static std::string DMTGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -6220,7 +6220,7 @@ std::string NMD::DMTGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMT(uint64 instruction, img_address m_pc)
+static std::string DMT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -6240,7 +6240,7 @@ std::string NMD::DMT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMUH(uint64 instruction, img_address m_pc)
+static std::string DMUH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6264,7 +6264,7 @@ std::string NMD::DMUH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMUHU(uint64 instruction, img_address m_pc)
+static std::string DMUHU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6288,7 +6288,7 @@ std::string NMD::DMUHU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMUL(uint64 instruction, img_address m_pc)
+static std::string DMUL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6312,7 +6312,7 @@ std::string NMD::DMUL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DMULU(uint64 instruction, img_address m_pc)
+static std::string DMULU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6337,7 +6337,7 @@ std::string NMD::DMULU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::DPA_W_PH(uint64 instruction, img_address m_pc)
+static std::string DPA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6361,7 +6361,7 @@ std::string NMD::DPA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAQ_SA_L_W(uint64 instruction, img_address m_pc)
+static std::string DPAQ_SA_L_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6385,7 +6385,7 @@ std::string NMD::DPAQ_SA_L_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAQ_S_W_PH(uint64 instruction, img_address m_pc)
+static std::string DPAQ_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6409,7 +6409,7 @@ std::string NMD::DPAQ_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAQX_SA_W_PH(uint64 instruction, img_address m_pc)
+static std::string DPAQX_SA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6433,7 +6433,7 @@ std::string NMD::DPAQX_SA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAQX_S_W_PH(uint64 instruction, img_address m_pc)
+static std::string DPAQX_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6457,7 +6457,7 @@ std::string NMD::DPAQX_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAU_H_QBL(uint64 instruction, img_address m_pc)
+static std::string DPAU_H_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6481,7 +6481,7 @@ std::string NMD::DPAU_H_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAU_H_QBR(uint64 instruction, img_address m_pc)
+static std::string DPAU_H_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6505,7 +6505,7 @@ std::string NMD::DPAU_H_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPAX_W_PH(uint64 instruction, img_address m_pc)
+static std::string DPAX_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6529,7 +6529,7 @@ std::string NMD::DPAX_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPS_W_PH(uint64 instruction, img_address m_pc)
+static std::string DPS_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6553,7 +6553,7 @@ std::string NMD::DPS_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSQ_SA_L_W(uint64 instruction, img_address m_pc)
+static std::string DPSQ_SA_L_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6577,7 +6577,7 @@ std::string NMD::DPSQ_SA_L_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSQ_S_W_PH(uint64 instruction, img_address m_pc)
+static std::string DPSQ_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6601,7 +6601,7 @@ std::string NMD::DPSQ_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSQX_SA_W_PH(uint64 instruction, img_address m_pc)
+static std::string DPSQX_SA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6625,7 +6625,7 @@ std::string NMD::DPSQX_SA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSQX_S_W_PH(uint64 instruction, img_address m_pc)
+static std::string DPSQX_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6649,7 +6649,7 @@ std::string NMD::DPSQX_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSU_H_QBL(uint64 instruction, img_address m_pc)
+static std::string DPSU_H_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6673,7 +6673,7 @@ std::string NMD::DPSU_H_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSU_H_QBR(uint64 instruction, img_address m_pc)
+static std::string DPSU_H_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6697,7 +6697,7 @@ std::string NMD::DPSU_H_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DPSX_W_PH(uint64 instruction, img_address m_pc)
+static std::string DPSX_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6721,7 +6721,7 @@ std::string NMD::DPSX_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DROTR(uint64 instruction, img_address m_pc)
+static std::string DROTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6745,7 +6745,7 @@ std::string NMD::DROTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DROTR32(uint64 instruction, img_address m_pc)
+static std::string DROTR32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6769,7 +6769,7 @@ std::string NMD::DROTR32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DROTRV(uint64 instruction, img_address m_pc)
+static std::string DROTRV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6793,7 +6793,7 @@ std::string NMD::DROTRV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DROTX(uint64 instruction, img_address m_pc)
+static std::string DROTX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6819,7 +6819,7 @@ std::string NMD::DROTX(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSLL(uint64 instruction, img_address m_pc)
+static std::string DSLL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6843,7 +6843,7 @@ std::string NMD::DSLL(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSLL32(uint64 instruction, img_address m_pc)
+static std::string DSLL32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6867,7 +6867,7 @@ std::string NMD::DSLL32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DSLLV(uint64 instruction, img_address m_pc)
+static std::string DSLLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6891,7 +6891,7 @@ std::string NMD::DSLLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSRA(uint64 instruction, img_address m_pc)
+static std::string DSRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6915,7 +6915,7 @@ std::string NMD::DSRA(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSRA32(uint64 instruction, img_address m_pc)
+static std::string DSRA32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6939,7 +6939,7 @@ std::string NMD::DSRA32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DSRAV(uint64 instruction, img_address m_pc)
+static std::string DSRAV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6963,7 +6963,7 @@ std::string NMD::DSRAV(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSRL(uint64 instruction, img_address m_pc)
+static std::string DSRL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -6987,7 +6987,7 @@ std::string NMD::DSRL(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-std::string NMD::DSRL32(uint64 instruction, img_address m_pc)
+static std::string DSRL32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7011,7 +7011,7 @@ std::string NMD::DSRL32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DSRLV(uint64 instruction, img_address m_pc)
+static std::string DSRLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7035,7 +7035,7 @@ std::string NMD::DSRLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DSUB(uint64 instruction, img_address m_pc)
+static std::string DSUB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7059,7 +7059,7 @@ std::string NMD::DSUB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DSUBU(uint64 instruction, img_address m_pc)
+static std::string DSUBU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7083,7 +7083,7 @@ std::string NMD::DSUBU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DVPE(uint64 instruction, img_address m_pc)
+static std::string DVPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7103,7 +7103,7 @@ std::string NMD::DVPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::DVP(uint64 instruction, img_address m_pc)
+static std::string DVP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7123,7 +7123,7 @@ std::string NMD::DVP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EHB(uint64 instruction, img_address m_pc)
+static std::string EHB(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -7141,7 +7141,7 @@ std::string NMD::EHB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EI(uint64 instruction, img_address m_pc)
+static std::string EI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7161,7 +7161,7 @@ std::string NMD::EI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EMT(uint64 instruction, img_address m_pc)
+static std::string EMT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7181,7 +7181,7 @@ std::string NMD::EMT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ERET(uint64 instruction, img_address m_pc)
+static std::string ERET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -7199,7 +7199,7 @@ std::string NMD::ERET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ERETNC(uint64 instruction, img_address m_pc)
+static std::string ERETNC(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -7217,7 +7217,7 @@ std::string NMD::ERETNC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EVP(uint64 instruction, img_address m_pc)
+static std::string EVP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7237,7 +7237,7 @@ std::string NMD::EVP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EVPE(uint64 instruction, img_address m_pc)
+static std::string EVPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
@@ -7257,7 +7257,7 @@ std::string NMD::EVPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXT(uint64 instruction, img_address m_pc)
+static std::string EXT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7283,7 +7283,7 @@ std::string NMD::EXT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTD(uint64 instruction, img_address m_pc)
+static std::string EXTD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7309,7 +7309,7 @@ std::string NMD::EXTD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTD32(uint64 instruction, img_address m_pc)
+static std::string EXTD32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7335,7 +7335,7 @@ std::string NMD::EXTD32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTPDP(uint64 instruction, img_address m_pc)
+static std::string EXTPDP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 size_value = extract_size_20_19_18_17_16(instruction);
@@ -7359,7 +7359,7 @@ std::string NMD::EXTPDP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTPDPV(uint64 instruction, img_address m_pc)
+static std::string EXTPDPV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7383,7 +7383,7 @@ std::string NMD::EXTPDPV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTP(uint64 instruction, img_address m_pc)
+static std::string EXTP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 size_value = extract_size_20_19_18_17_16(instruction);
@@ -7407,7 +7407,7 @@ std::string NMD::EXTP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::EXTPV(uint64 instruction, img_address m_pc)
+static std::string EXTPV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7432,7 +7432,7 @@ std::string NMD::EXTPV(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-std::string NMD::EXTR_RS_W(uint64 instruction, img_address m_pc)
+static std::string EXTR_RS_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
@@ -7457,7 +7457,7 @@ std::string NMD::EXTR_RS_W(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-std::string NMD::EXTR_R_W(uint64 instruction, img_address m_pc)
+static std::string EXTR_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
@@ -7482,7 +7482,7 @@ std::string NMD::EXTR_R_W(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-std::string NMD::EXTR_S_H(uint64 instruction, img_address m_pc)
+static std::string EXTR_S_H(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
@@ -7507,7 +7507,7 @@ std::string NMD::EXTR_S_H(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-std::string NMD::EXTR_W(uint64 instruction, img_address m_pc)
+static std::string EXTR_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
@@ -7532,7 +7532,7 @@ std::string NMD::EXTR_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::EXTRV_RS_W(uint64 instruction, img_address m_pc)
+static std::string EXTRV_RS_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7557,7 +7557,7 @@ std::string NMD::EXTRV_RS_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::EXTRV_R_W(uint64 instruction, img_address m_pc)
+static std::string EXTRV_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7582,7 +7582,7 @@ std::string NMD::EXTRV_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::EXTRV_S_H(uint64 instruction, img_address m_pc)
+static std::string EXTRV_S_H(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7607,7 +7607,7 @@ std::string NMD::EXTRV_S_H(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::EXTRV_W(uint64 instruction, img_address m_pc)
+static std::string EXTRV_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7632,7 +7632,7 @@ std::string NMD::EXTRV_W(uint64 instruction, img_address m_pc)
  *               rd -----
  *                 shift -----
  */
-std::string NMD::EXTW(uint64 instruction, img_address m_pc)
+static std::string EXTW(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7658,7 +7658,7 @@ std::string NMD::EXTW(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::FLOOR_L_D(uint64 instruction, img_address m_pc)
+static std::string FLOOR_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -7680,7 +7680,7 @@ std::string NMD::FLOOR_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::FLOOR_L_S(uint64 instruction, img_address m_pc)
+static std::string FLOOR_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -7702,7 +7702,7 @@ std::string NMD::FLOOR_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::FLOOR_W_D(uint64 instruction, img_address m_pc)
+static std::string FLOOR_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -7724,7 +7724,7 @@ std::string NMD::FLOOR_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::FLOOR_W_S(uint64 instruction, img_address m_pc)
+static std::string FLOOR_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -7746,7 +7746,7 @@ std::string NMD::FLOOR_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::FORK(uint64 instruction, img_address m_pc)
+static std::string FORK(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7770,7 +7770,7 @@ std::string NMD::FORK(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::HYPCALL(uint64 instruction, img_address m_pc)
+static std::string HYPCALL(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
@@ -7790,7 +7790,7 @@ std::string NMD::HYPCALL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::HYPCALL_16_(uint64 instruction, img_address m_pc)
+static std::string HYPCALL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
@@ -7810,7 +7810,7 @@ std::string NMD::HYPCALL_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::INS(uint64 instruction, img_address m_pc)
+static std::string INS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7837,7 +7837,7 @@ std::string NMD::INS(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::INSV(uint64 instruction, img_address m_pc)
+static std::string INSV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7859,7 +7859,7 @@ std::string NMD::INSV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::IRET(uint64 instruction, img_address m_pc)
+static std::string IRET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -7877,7 +7877,7 @@ std::string NMD::IRET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::JALRC_16_(uint64 instruction, img_address m_pc)
+static std::string JALRC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
 
@@ -7897,7 +7897,7 @@ std::string NMD::JALRC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::JALRC_32_(uint64 instruction, img_address m_pc)
+static std::string JALRC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7919,7 +7919,7 @@ std::string NMD::JALRC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::JALRC_HB(uint64 instruction, img_address m_pc)
+static std::string JALRC_HB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -7941,7 +7941,7 @@ std::string NMD::JALRC_HB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::JRC(uint64 instruction, img_address m_pc)
+static std::string JRC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
 
@@ -7961,7 +7961,7 @@ std::string NMD::JRC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LB_16_(uint64 instruction, img_address m_pc)
+static std::string LB_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -7985,7 +7985,7 @@ std::string NMD::LB_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LB_GP_(uint64 instruction, img_address m_pc)
+static std::string LB_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
@@ -8007,7 +8007,7 @@ std::string NMD::LB_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LB_S9_(uint64 instruction, img_address m_pc)
+static std::string LB_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8031,7 +8031,7 @@ std::string NMD::LB_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LB_U12_(uint64 instruction, img_address m_pc)
+static std::string LB_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8055,7 +8055,7 @@ std::string NMD::LB_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBE(uint64 instruction, img_address m_pc)
+static std::string LBE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8079,7 +8079,7 @@ std::string NMD::LBE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBU_16_(uint64 instruction, img_address m_pc)
+static std::string LBU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -8103,7 +8103,7 @@ std::string NMD::LBU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBU_GP_(uint64 instruction, img_address m_pc)
+static std::string LBU_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
@@ -8125,7 +8125,7 @@ std::string NMD::LBU_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBU_S9_(uint64 instruction, img_address m_pc)
+static std::string LBU_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8149,7 +8149,7 @@ std::string NMD::LBU_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBU_U12_(uint64 instruction, img_address m_pc)
+static std::string LBU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8173,7 +8173,7 @@ std::string NMD::LBU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBUE(uint64 instruction, img_address m_pc)
+static std::string LBUE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8197,7 +8197,7 @@ std::string NMD::LBUE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBUX(uint64 instruction, img_address m_pc)
+static std::string LBUX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8221,7 +8221,7 @@ std::string NMD::LBUX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LBX(uint64 instruction, img_address m_pc)
+static std::string LBX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8245,7 +8245,7 @@ std::string NMD::LBX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LD_GP_(uint64 instruction, img_address m_pc)
+static std::string LD_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_3__s3(instruction);
@@ -8267,7 +8267,7 @@ std::string NMD::LD_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LD_S9_(uint64 instruction, img_address m_pc)
+static std::string LD_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8291,7 +8291,7 @@ std::string NMD::LD_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LD_U12_(uint64 instruction, img_address m_pc)
+static std::string LD_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8315,7 +8315,7 @@ std::string NMD::LD_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC1_GP_(uint64 instruction, img_address m_pc)
+static std::string LDC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
@@ -8337,7 +8337,7 @@ std::string NMD::LDC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC1_S9_(uint64 instruction, img_address m_pc)
+static std::string LDC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8361,7 +8361,7 @@ std::string NMD::LDC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC1_U12_(uint64 instruction, img_address m_pc)
+static std::string LDC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8385,7 +8385,7 @@ std::string NMD::LDC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC1XS(uint64 instruction, img_address m_pc)
+static std::string LDC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8409,7 +8409,7 @@ std::string NMD::LDC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC1X(uint64 instruction, img_address m_pc)
+static std::string LDC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8433,7 +8433,7 @@ std::string NMD::LDC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDC2(uint64 instruction, img_address m_pc)
+static std::string LDC2(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8457,7 +8457,7 @@ std::string NMD::LDC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDM(uint64 instruction, img_address m_pc)
+static std::string LDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8483,7 +8483,7 @@ std::string NMD::LDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDPC_48_(uint64 instruction, img_address m_pc)
+static std::string LDPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -8505,7 +8505,7 @@ std::string NMD::LDPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDX(uint64 instruction, img_address m_pc)
+static std::string LDX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8529,7 +8529,7 @@ std::string NMD::LDX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LDXS(uint64 instruction, img_address m_pc)
+static std::string LDXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8553,7 +8553,7 @@ std::string NMD::LDXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LH_16_(uint64 instruction, img_address m_pc)
+static std::string LH_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -8577,7 +8577,7 @@ std::string NMD::LH_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LH_GP_(uint64 instruction, img_address m_pc)
+static std::string LH_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
@@ -8599,7 +8599,7 @@ std::string NMD::LH_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LH_S9_(uint64 instruction, img_address m_pc)
+static std::string LH_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8623,7 +8623,7 @@ std::string NMD::LH_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LH_U12_(uint64 instruction, img_address m_pc)
+static std::string LH_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8647,7 +8647,7 @@ std::string NMD::LH_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHE(uint64 instruction, img_address m_pc)
+static std::string LHE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8671,7 +8671,7 @@ std::string NMD::LHE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHU_16_(uint64 instruction, img_address m_pc)
+static std::string LHU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -8695,7 +8695,7 @@ std::string NMD::LHU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHU_GP_(uint64 instruction, img_address m_pc)
+static std::string LHU_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
@@ -8717,7 +8717,7 @@ std::string NMD::LHU_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHU_S9_(uint64 instruction, img_address m_pc)
+static std::string LHU_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8741,7 +8741,7 @@ std::string NMD::LHU_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHU_U12_(uint64 instruction, img_address m_pc)
+static std::string LHU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8765,7 +8765,7 @@ std::string NMD::LHU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHUE(uint64 instruction, img_address m_pc)
+static std::string LHUE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8789,7 +8789,7 @@ std::string NMD::LHUE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHUX(uint64 instruction, img_address m_pc)
+static std::string LHUX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8813,7 +8813,7 @@ std::string NMD::LHUX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHUXS(uint64 instruction, img_address m_pc)
+static std::string LHUXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8837,7 +8837,7 @@ std::string NMD::LHUXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHXS(uint64 instruction, img_address m_pc)
+static std::string LHXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8861,7 +8861,7 @@ std::string NMD::LHXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LHX(uint64 instruction, img_address m_pc)
+static std::string LHX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8885,7 +8885,7 @@ std::string NMD::LHX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LI_16_(uint64 instruction, img_address m_pc)
+static std::string LI_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
@@ -8907,7 +8907,7 @@ std::string NMD::LI_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LI_48_(uint64 instruction, img_address m_pc)
+static std::string LI_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -8929,7 +8929,7 @@ std::string NMD::LI_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LL(uint64 instruction, img_address m_pc)
+static std::string LL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8953,7 +8953,7 @@ std::string NMD::LL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LLD(uint64 instruction, img_address m_pc)
+static std::string LLD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8977,7 +8977,7 @@ std::string NMD::LLD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LLDP(uint64 instruction, img_address m_pc)
+static std::string LLDP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9001,7 +9001,7 @@ std::string NMD::LLDP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LLE(uint64 instruction, img_address m_pc)
+static std::string LLE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9025,7 +9025,7 @@ std::string NMD::LLE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LLWP(uint64 instruction, img_address m_pc)
+static std::string LLWP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9049,7 +9049,7 @@ std::string NMD::LLWP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LLWPE(uint64 instruction, img_address m_pc)
+static std::string LLWPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9073,7 +9073,7 @@ std::string NMD::LLWPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LSA(uint64 instruction, img_address m_pc)
+static std::string LSA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9099,7 +9099,7 @@ std::string NMD::LSA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LUI(uint64 instruction, img_address m_pc)
+static std::string LUI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
@@ -9121,7 +9121,7 @@ std::string NMD::LUI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_16_(uint64 instruction, img_address m_pc)
+static std::string LW_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -9145,7 +9145,7 @@ std::string NMD::LW_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_4X4_(uint64 instruction, img_address m_pc)
+static std::string LW_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
@@ -9169,7 +9169,7 @@ std::string NMD::LW_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_GP_(uint64 instruction, img_address m_pc)
+static std::string LW_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
@@ -9191,7 +9191,7 @@ std::string NMD::LW_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_GP16_(uint64 instruction, img_address m_pc)
+static std::string LW_GP16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
@@ -9213,7 +9213,7 @@ std::string NMD::LW_GP16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_S9_(uint64 instruction, img_address m_pc)
+static std::string LW_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9237,7 +9237,7 @@ std::string NMD::LW_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_SP_(uint64 instruction, img_address m_pc)
+static std::string LW_SP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
@@ -9259,7 +9259,7 @@ std::string NMD::LW_SP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LW_U12_(uint64 instruction, img_address m_pc)
+static std::string LW_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9283,7 +9283,7 @@ std::string NMD::LW_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC1_GP_(uint64 instruction, img_address m_pc)
+static std::string LWC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
@@ -9305,7 +9305,7 @@ std::string NMD::LWC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC1_S9_(uint64 instruction, img_address m_pc)
+static std::string LWC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9329,7 +9329,7 @@ std::string NMD::LWC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC1_U12_(uint64 instruction, img_address m_pc)
+static std::string LWC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9353,7 +9353,7 @@ std::string NMD::LWC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC1X(uint64 instruction, img_address m_pc)
+static std::string LWC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9377,7 +9377,7 @@ std::string NMD::LWC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC1XS(uint64 instruction, img_address m_pc)
+static std::string LWC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9401,7 +9401,7 @@ std::string NMD::LWC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWC2(uint64 instruction, img_address m_pc)
+static std::string LWC2(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9425,7 +9425,7 @@ std::string NMD::LWC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWE(uint64 instruction, img_address m_pc)
+static std::string LWE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9449,7 +9449,7 @@ std::string NMD::LWE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWM(uint64 instruction, img_address m_pc)
+static std::string LWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9475,7 +9475,7 @@ std::string NMD::LWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWPC_48_(uint64 instruction, img_address m_pc)
+static std::string LWPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -9497,7 +9497,7 @@ std::string NMD::LWPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWU_GP_(uint64 instruction, img_address m_pc)
+static std::string LWU_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
@@ -9519,7 +9519,7 @@ std::string NMD::LWU_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWU_S9_(uint64 instruction, img_address m_pc)
+static std::string LWU_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9543,7 +9543,7 @@ std::string NMD::LWU_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWU_U12_(uint64 instruction, img_address m_pc)
+static std::string LWU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9567,7 +9567,7 @@ std::string NMD::LWU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWUX(uint64 instruction, img_address m_pc)
+static std::string LWUX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9591,7 +9591,7 @@ std::string NMD::LWUX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWUXS(uint64 instruction, img_address m_pc)
+static std::string LWUXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9615,7 +9615,7 @@ std::string NMD::LWUXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWX(uint64 instruction, img_address m_pc)
+static std::string LWX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9639,7 +9639,7 @@ std::string NMD::LWX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWXS_16_(uint64 instruction, img_address m_pc)
+static std::string LWXS_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -9663,7 +9663,7 @@ std::string NMD::LWXS_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::LWXS_32_(uint64 instruction, img_address m_pc)
+static std::string LWXS_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9688,7 +9688,7 @@ std::string NMD::LWXS_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MADD_DSP_(uint64 instruction, img_address m_pc)
+static std::string MADD_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9712,7 +9712,7 @@ std::string NMD::MADD_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MADDF_D(uint64 instruction, img_address m_pc)
+static std::string MADDF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -9736,7 +9736,7 @@ std::string NMD::MADDF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MADDF_S(uint64 instruction, img_address m_pc)
+static std::string MADDF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -9761,7 +9761,7 @@ std::string NMD::MADDF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MADDU_DSP_(uint64 instruction, img_address m_pc)
+static std::string MADDU_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9786,7 +9786,7 @@ std::string NMD::MADDU_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAQ_S_W_PHL(uint64 instruction, img_address m_pc)
+static std::string MAQ_S_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9811,7 +9811,7 @@ std::string NMD::MAQ_S_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAQ_S_W_PHR(uint64 instruction, img_address m_pc)
+static std::string MAQ_S_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9836,7 +9836,7 @@ std::string NMD::MAQ_S_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAQ_SA_W_PHL(uint64 instruction, img_address m_pc)
+static std::string MAQ_SA_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9861,7 +9861,7 @@ std::string NMD::MAQ_SA_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAQ_SA_W_PHR(uint64 instruction, img_address m_pc)
+static std::string MAQ_SA_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9885,7 +9885,7 @@ std::string NMD::MAQ_SA_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAX_D(uint64 instruction, img_address m_pc)
+static std::string MAX_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -9909,7 +9909,7 @@ std::string NMD::MAX_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAX_S(uint64 instruction, img_address m_pc)
+static std::string MAX_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -9933,7 +9933,7 @@ std::string NMD::MAX_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAXA_D(uint64 instruction, img_address m_pc)
+static std::string MAXA_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -9957,7 +9957,7 @@ std::string NMD::MAXA_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MAXA_S(uint64 instruction, img_address m_pc)
+static std::string MAXA_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -9981,7 +9981,7 @@ std::string NMD::MAXA_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFC0(uint64 instruction, img_address m_pc)
+static std::string MFC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10005,7 +10005,7 @@ std::string NMD::MFC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFC1(uint64 instruction, img_address m_pc)
+static std::string MFC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10027,7 +10027,7 @@ std::string NMD::MFC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFC2(uint64 instruction, img_address m_pc)
+static std::string MFC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -10049,7 +10049,7 @@ std::string NMD::MFC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFGC0(uint64 instruction, img_address m_pc)
+static std::string MFGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10073,7 +10073,7 @@ std::string NMD::MFGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFHC0(uint64 instruction, img_address m_pc)
+static std::string MFHC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10097,7 +10097,7 @@ std::string NMD::MFHC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFHC1(uint64 instruction, img_address m_pc)
+static std::string MFHC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10119,7 +10119,7 @@ std::string NMD::MFHC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFHC2(uint64 instruction, img_address m_pc)
+static std::string MFHC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -10141,7 +10141,7 @@ std::string NMD::MFHC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFHGC0(uint64 instruction, img_address m_pc)
+static std::string MFHGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10164,7 +10164,7 @@ std::string NMD::MFHGC0(uint64 instruction, img_address m_pc)
  *     rt -----
  *               ac --
  */
-std::string NMD::MFHI_DSP_(uint64 instruction, img_address m_pc)
+static std::string MFHI_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -10186,7 +10186,7 @@ std::string NMD::MFHI_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFHTR(uint64 instruction, img_address m_pc)
+static std::string MFHTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10211,7 +10211,7 @@ std::string NMD::MFHTR(uint64 instruction, img_address m_pc)
  *     rt -----
  *               ac --
  */
-std::string NMD::MFLO_DSP_(uint64 instruction, img_address m_pc)
+static std::string MFLO_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -10233,7 +10233,7 @@ std::string NMD::MFLO_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MFTR(uint64 instruction, img_address m_pc)
+static std::string MFTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10259,7 +10259,7 @@ std::string NMD::MFTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MIN_D(uint64 instruction, img_address m_pc)
+static std::string MIN_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10283,7 +10283,7 @@ std::string NMD::MIN_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MIN_S(uint64 instruction, img_address m_pc)
+static std::string MIN_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10307,7 +10307,7 @@ std::string NMD::MIN_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MINA_D(uint64 instruction, img_address m_pc)
+static std::string MINA_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10331,7 +10331,7 @@ std::string NMD::MINA_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MINA_S(uint64 instruction, img_address m_pc)
+static std::string MINA_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10355,7 +10355,7 @@ std::string NMD::MINA_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOD(uint64 instruction, img_address m_pc)
+static std::string MOD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10379,7 +10379,7 @@ std::string NMD::MOD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MODSUB(uint64 instruction, img_address m_pc)
+static std::string MODSUB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10403,7 +10403,7 @@ std::string NMD::MODSUB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MODU(uint64 instruction, img_address m_pc)
+static std::string MODU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10427,7 +10427,7 @@ std::string NMD::MODU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOV_D(uint64 instruction, img_address m_pc)
+static std::string MOV_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10449,7 +10449,7 @@ std::string NMD::MOV_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOV_S(uint64 instruction, img_address m_pc)
+static std::string MOV_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10471,7 +10471,7 @@ std::string NMD::MOV_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVE_BALC(uint64 instruction, img_address m_pc)
+static std::string MOVE_BALC(uint64 instruction, img_address m_pc)
 {
     uint64 rtz4_value = extract_rtz4_27_26_25_23_22_21(instruction);
     uint64 rd1_value = extract_rdl_25_24(instruction);
@@ -10495,7 +10495,7 @@ std::string NMD::MOVE_BALC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVEP(uint64 instruction, img_address m_pc)
+static std::string MOVEP(uint64 instruction, img_address m_pc)
 {
     uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
     uint64 rd2_value = extract_rd2_3_8(instruction);
@@ -10522,7 +10522,7 @@ std::string NMD::MOVEP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVEP_REV_(uint64 instruction, img_address m_pc)
+static std::string MOVEP_REV_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rd2_value = extract_rd2_3_8(instruction);
@@ -10549,7 +10549,7 @@ std::string NMD::MOVEP_REV_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVE(uint64 instruction, img_address m_pc)
+static std::string MOVE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
@@ -10571,7 +10571,7 @@ std::string NMD::MOVE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVN(uint64 instruction, img_address m_pc)
+static std::string MOVN(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10595,7 +10595,7 @@ std::string NMD::MOVN(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MOVZ(uint64 instruction, img_address m_pc)
+static std::string MOVZ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10619,7 +10619,7 @@ std::string NMD::MOVZ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::MSUB_DSP_(uint64 instruction, img_address m_pc)
+static std::string MSUB_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10643,7 +10643,7 @@ std::string NMD::MSUB_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MSUBF_D(uint64 instruction, img_address m_pc)
+static std::string MSUBF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10667,7 +10667,7 @@ std::string NMD::MSUBF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MSUBF_S(uint64 instruction, img_address m_pc)
+static std::string MSUBF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10691,7 +10691,7 @@ std::string NMD::MSUBF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::MSUBU_DSP_(uint64 instruction, img_address m_pc)
+static std::string MSUBU_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -10715,7 +10715,7 @@ std::string NMD::MSUBU_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTC0(uint64 instruction, img_address m_pc)
+static std::string MTC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10739,7 +10739,7 @@ std::string NMD::MTC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTC1(uint64 instruction, img_address m_pc)
+static std::string MTC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10761,7 +10761,7 @@ std::string NMD::MTC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTC2(uint64 instruction, img_address m_pc)
+static std::string MTC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -10783,7 +10783,7 @@ std::string NMD::MTC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTGC0(uint64 instruction, img_address m_pc)
+static std::string MTGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10807,7 +10807,7 @@ std::string NMD::MTGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTHC0(uint64 instruction, img_address m_pc)
+static std::string MTHC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10831,7 +10831,7 @@ std::string NMD::MTHC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTHC1(uint64 instruction, img_address m_pc)
+static std::string MTHC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -10853,7 +10853,7 @@ std::string NMD::MTHC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTHC2(uint64 instruction, img_address m_pc)
+static std::string MTHC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
@@ -10875,7 +10875,7 @@ std::string NMD::MTHC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTHGC0(uint64 instruction, img_address m_pc)
+static std::string MTHGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10898,7 +10898,7 @@ std::string NMD::MTHGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::MTHI_DSP_(uint64 instruction, img_address m_pc)
+static std::string MTHI_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -10919,7 +10919,7 @@ std::string NMD::MTHI_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::MTHLIP(uint64 instruction, img_address m_pc)
+static std::string MTHLIP(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -10941,7 +10941,7 @@ std::string NMD::MTHLIP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTHTR(uint64 instruction, img_address m_pc)
+static std::string MTHTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -10966,7 +10966,7 @@ std::string NMD::MTHTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::MTLO_DSP_(uint64 instruction, img_address m_pc)
+static std::string MTLO_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -10988,7 +10988,7 @@ std::string NMD::MTLO_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MTTR(uint64 instruction, img_address m_pc)
+static std::string MTTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
@@ -11014,7 +11014,7 @@ std::string NMD::MTTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUH(uint64 instruction, img_address m_pc)
+static std::string MUH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11038,7 +11038,7 @@ std::string NMD::MUH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUHU(uint64 instruction, img_address m_pc)
+static std::string MUHU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11062,7 +11062,7 @@ std::string NMD::MUHU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_32_(uint64 instruction, img_address m_pc)
+static std::string MUL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11086,7 +11086,7 @@ std::string NMD::MUL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_4X4_(uint64 instruction, img_address m_pc)
+static std::string MUL_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
@@ -11108,7 +11108,7 @@ std::string NMD::MUL_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_D(uint64 instruction, img_address m_pc)
+static std::string MUL_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -11133,7 +11133,7 @@ std::string NMD::MUL_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_PH(uint64 instruction, img_address m_pc)
+static std::string MUL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11158,7 +11158,7 @@ std::string NMD::MUL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_S_PH(uint64 instruction, img_address m_pc)
+static std::string MUL_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11182,7 +11182,7 @@ std::string NMD::MUL_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MUL_S(uint64 instruction, img_address m_pc)
+static std::string MUL_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -11207,7 +11207,7 @@ std::string NMD::MUL_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULEQ_S_W_PHL(uint64 instruction, img_address m_pc)
+static std::string MULEQ_S_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11232,7 +11232,7 @@ std::string NMD::MULEQ_S_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULEQ_S_W_PHR(uint64 instruction, img_address m_pc)
+static std::string MULEQ_S_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11257,7 +11257,7 @@ std::string NMD::MULEQ_S_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULEU_S_PH_QBL(uint64 instruction, img_address m_pc)
+static std::string MULEU_S_PH_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11282,7 +11282,7 @@ std::string NMD::MULEU_S_PH_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULEU_S_PH_QBR(uint64 instruction, img_address m_pc)
+static std::string MULEU_S_PH_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11307,7 +11307,7 @@ std::string NMD::MULEU_S_PH_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULQ_RS_PH(uint64 instruction, img_address m_pc)
+static std::string MULQ_RS_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11332,7 +11332,7 @@ std::string NMD::MULQ_RS_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULQ_RS_W(uint64 instruction, img_address m_pc)
+static std::string MULQ_RS_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11357,7 +11357,7 @@ std::string NMD::MULQ_RS_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULQ_S_PH(uint64 instruction, img_address m_pc)
+static std::string MULQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11382,7 +11382,7 @@ std::string NMD::MULQ_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULQ_S_W(uint64 instruction, img_address m_pc)
+static std::string MULQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11407,7 +11407,7 @@ std::string NMD::MULQ_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::MULSA_W_PH(uint64 instruction, img_address m_pc)
+static std::string MULSA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11432,7 +11432,7 @@ std::string NMD::MULSA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::MULSAQ_S_W_PH(uint64 instruction, img_address m_pc)
+static std::string MULSAQ_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11456,7 +11456,7 @@ std::string NMD::MULSAQ_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::MULT_DSP_(uint64 instruction, img_address m_pc)
+static std::string MULT_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11480,7 +11480,7 @@ std::string NMD::MULT_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::MULTU_DSP_(uint64 instruction, img_address m_pc)
+static std::string MULTU_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11504,7 +11504,7 @@ std::string NMD::MULTU_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::MULU(uint64 instruction, img_address m_pc)
+static std::string MULU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11528,7 +11528,7 @@ std::string NMD::MULU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NEG_D(uint64 instruction, img_address m_pc)
+static std::string NEG_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -11550,7 +11550,7 @@ std::string NMD::NEG_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NEG_S(uint64 instruction, img_address m_pc)
+static std::string NEG_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -11572,7 +11572,7 @@ std::string NMD::NEG_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NOP_16_(uint64 instruction, img_address m_pc)
+static std::string NOP_16_(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -11590,7 +11590,7 @@ std::string NMD::NOP_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NOP_32_(uint64 instruction, img_address m_pc)
+static std::string NOP_32_(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -11608,7 +11608,7 @@ std::string NMD::NOP_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NOR(uint64 instruction, img_address m_pc)
+static std::string NOR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11632,7 +11632,7 @@ std::string NMD::NOR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::NOT_16_(uint64 instruction, img_address m_pc)
+static std::string NOT_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -11654,7 +11654,7 @@ std::string NMD::NOT_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::OR_16_(uint64 instruction, img_address m_pc)
+static std::string OR_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -11676,7 +11676,7 @@ std::string NMD::OR_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::OR_32_(uint64 instruction, img_address m_pc)
+static std::string OR_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11700,7 +11700,7 @@ std::string NMD::OR_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ORI(uint64 instruction, img_address m_pc)
+static std::string ORI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11725,7 +11725,7 @@ std::string NMD::ORI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PACKRL_PH(uint64 instruction, img_address m_pc)
+static std::string PACKRL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11749,7 +11749,7 @@ std::string NMD::PACKRL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PAUSE(uint64 instruction, img_address m_pc)
+static std::string PAUSE(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -11768,7 +11768,7 @@ std::string NMD::PAUSE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PICK_PH(uint64 instruction, img_address m_pc)
+static std::string PICK_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11793,7 +11793,7 @@ std::string NMD::PICK_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PICK_QB(uint64 instruction, img_address m_pc)
+static std::string PICK_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11818,7 +11818,7 @@ std::string NMD::PICK_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQ_W_PHL(uint64 instruction, img_address m_pc)
+static std::string PRECEQ_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11841,7 +11841,7 @@ std::string NMD::PRECEQ_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQ_W_PHR(uint64 instruction, img_address m_pc)
+static std::string PRECEQ_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11864,7 +11864,7 @@ std::string NMD::PRECEQ_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc)
+static std::string PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11887,7 +11887,7 @@ std::string NMD::PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQU_PH_QBL(uint64 instruction, img_address m_pc)
+static std::string PRECEQU_PH_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11910,7 +11910,7 @@ std::string NMD::PRECEQU_PH_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc)
+static std::string PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11933,7 +11933,7 @@ std::string NMD::PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEQU_PH_QBR(uint64 instruction, img_address m_pc)
+static std::string PRECEQU_PH_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11957,7 +11957,7 @@ std::string NMD::PRECEQU_PH_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEU_PH_QBLA(uint64 instruction, img_address m_pc)
+static std::string PRECEU_PH_QBLA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -11980,7 +11980,7 @@ std::string NMD::PRECEU_PH_QBLA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEU_PH_QBL(uint64 instruction, img_address m_pc)
+static std::string PRECEU_PH_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12004,7 +12004,7 @@ std::string NMD::PRECEU_PH_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEU_PH_QBRA(uint64 instruction, img_address m_pc)
+static std::string PRECEU_PH_QBRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12027,7 +12027,7 @@ std::string NMD::PRECEU_PH_QBRA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECEU_PH_QBR(uint64 instruction, img_address m_pc)
+static std::string PRECEU_PH_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12050,7 +12050,7 @@ std::string NMD::PRECEU_PH_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECR_QB_PH(uint64 instruction, img_address m_pc)
+static std::string PRECR_QB_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12075,7 +12075,7 @@ std::string NMD::PRECR_QB_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECR_SRA_PH_W(uint64 instruction, img_address m_pc)
+static std::string PRECR_SRA_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12100,7 +12100,7 @@ std::string NMD::PRECR_SRA_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc)
+static std::string PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12125,7 +12125,7 @@ std::string NMD::PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECRQ_PH_W(uint64 instruction, img_address m_pc)
+static std::string PRECRQ_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12150,7 +12150,7 @@ std::string NMD::PRECRQ_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECRQ_QB_PH(uint64 instruction, img_address m_pc)
+static std::string PRECRQ_QB_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12175,7 +12175,7 @@ std::string NMD::PRECRQ_QB_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc)
+static std::string PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12200,7 +12200,7 @@ std::string NMD::PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc)
+static std::string PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12224,7 +12224,7 @@ std::string NMD::PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PREF_S9_(uint64 instruction, img_address m_pc)
+static std::string PREF_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12248,7 +12248,7 @@ std::string NMD::PREF_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PREF_U12_(uint64 instruction, img_address m_pc)
+static std::string PREF_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12272,7 +12272,7 @@ std::string NMD::PREF_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PREFE(uint64 instruction, img_address m_pc)
+static std::string PREFE(uint64 instruction, img_address m_pc)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12296,7 +12296,7 @@ std::string NMD::PREFE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::PREPEND(uint64 instruction, img_address m_pc)
+static std::string PREPEND(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12319,7 +12319,7 @@ std::string NMD::PREPEND(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::RADDU_W_QB(uint64 instruction, img_address m_pc)
+static std::string RADDU_W_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12340,7 +12340,7 @@ std::string NMD::RADDU_W_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *        mask -------
  */
-std::string NMD::RDDSP(uint64 instruction, img_address m_pc)
+static std::string RDDSP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
@@ -12362,7 +12362,7 @@ std::string NMD::RDDSP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RDHWR(uint64 instruction, img_address m_pc)
+static std::string RDHWR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
@@ -12386,7 +12386,7 @@ std::string NMD::RDHWR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RDPGPR(uint64 instruction, img_address m_pc)
+static std::string RDPGPR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12408,7 +12408,7 @@ std::string NMD::RDPGPR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RECIP_D(uint64 instruction, img_address m_pc)
+static std::string RECIP_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12430,7 +12430,7 @@ std::string NMD::RECIP_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RECIP_S(uint64 instruction, img_address m_pc)
+static std::string RECIP_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12452,7 +12452,7 @@ std::string NMD::RECIP_S(uint64 instruction, img_address m_pc)
  *     rt -----
  *           s ----------
  */
-std::string NMD::REPL_PH(uint64 instruction, img_address m_pc)
+static std::string REPL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se9_20_19_18_17_16_15_14_13_12_11(instruction);
@@ -12474,7 +12474,7 @@ std::string NMD::REPL_PH(uint64 instruction, img_address m_pc)
  *     rt -----
  *           u --------
  */
-std::string NMD::REPL_QB(uint64 instruction, img_address m_pc)
+static std::string REPL_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
@@ -12496,7 +12496,7 @@ std::string NMD::REPL_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::REPLV_PH(uint64 instruction, img_address m_pc)
+static std::string REPLV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12517,7 +12517,7 @@ std::string NMD::REPLV_PH(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::REPLV_QB(uint64 instruction, img_address m_pc)
+static std::string REPLV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12539,7 +12539,7 @@ std::string NMD::REPLV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RESTORE_32_(uint64 instruction, img_address m_pc)
+static std::string RESTORE_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 count_value = extract_count_19_18_17_16(instruction);
@@ -12562,7 +12562,7 @@ std::string NMD::RESTORE_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
+static std::string RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt1_value = extract_rtl_11(instruction);
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
@@ -12584,7 +12584,7 @@ std::string NMD::RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
+static std::string RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 count_value = extract_count_19_18_17_16(instruction);
@@ -12607,7 +12607,7 @@ std::string NMD::RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RESTOREF(uint64 instruction, img_address m_pc)
+static std::string RESTOREF(uint64 instruction, img_address m_pc)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
@@ -12629,7 +12629,7 @@ std::string NMD::RESTOREF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RINT_D(uint64 instruction, img_address m_pc)
+static std::string RINT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12651,7 +12651,7 @@ std::string NMD::RINT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RINT_S(uint64 instruction, img_address m_pc)
+static std::string RINT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12673,7 +12673,7 @@ std::string NMD::RINT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROTR(uint64 instruction, img_address m_pc)
+static std::string ROTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12697,7 +12697,7 @@ std::string NMD::ROTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROTRV(uint64 instruction, img_address m_pc)
+static std::string ROTRV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12721,7 +12721,7 @@ std::string NMD::ROTRV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROTX(uint64 instruction, img_address m_pc)
+static std::string ROTX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12750,7 +12750,7 @@ std::string NMD::ROTX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROUND_L_D(uint64 instruction, img_address m_pc)
+static std::string ROUND_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12772,7 +12772,7 @@ std::string NMD::ROUND_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROUND_L_S(uint64 instruction, img_address m_pc)
+static std::string ROUND_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12794,7 +12794,7 @@ std::string NMD::ROUND_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROUND_W_D(uint64 instruction, img_address m_pc)
+static std::string ROUND_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12816,7 +12816,7 @@ std::string NMD::ROUND_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::ROUND_W_S(uint64 instruction, img_address m_pc)
+static std::string ROUND_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12838,7 +12838,7 @@ std::string NMD::ROUND_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RSQRT_D(uint64 instruction, img_address m_pc)
+static std::string RSQRT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12860,7 +12860,7 @@ std::string NMD::RSQRT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::RSQRT_S(uint64 instruction, img_address m_pc)
+static std::string RSQRT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -12882,7 +12882,7 @@ std::string NMD::RSQRT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SAVE_16_(uint64 instruction, img_address m_pc)
+static std::string SAVE_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt1_value = extract_rtl_11(instruction);
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
@@ -12904,7 +12904,7 @@ std::string NMD::SAVE_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SAVE_32_(uint64 instruction, img_address m_pc)
+static std::string SAVE_32_(uint64 instruction, img_address m_pc)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
@@ -12927,7 +12927,7 @@ std::string NMD::SAVE_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SAVEF(uint64 instruction, img_address m_pc)
+static std::string SAVEF(uint64 instruction, img_address m_pc)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
@@ -12949,7 +12949,7 @@ std::string NMD::SAVEF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SB_16_(uint64 instruction, img_address m_pc)
+static std::string SB_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -12973,7 +12973,7 @@ std::string NMD::SB_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SB_GP_(uint64 instruction, img_address m_pc)
+static std::string SB_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
@@ -12995,7 +12995,7 @@ std::string NMD::SB_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SB_S9_(uint64 instruction, img_address m_pc)
+static std::string SB_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13019,7 +13019,7 @@ std::string NMD::SB_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SB_U12_(uint64 instruction, img_address m_pc)
+static std::string SB_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13043,7 +13043,7 @@ std::string NMD::SB_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SBE(uint64 instruction, img_address m_pc)
+static std::string SBE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13067,7 +13067,7 @@ std::string NMD::SBE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SBX(uint64 instruction, img_address m_pc)
+static std::string SBX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13091,7 +13091,7 @@ std::string NMD::SBX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SC(uint64 instruction, img_address m_pc)
+static std::string SC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13115,7 +13115,7 @@ std::string NMD::SC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SCD(uint64 instruction, img_address m_pc)
+static std::string SCD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13139,7 +13139,7 @@ std::string NMD::SCD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SCDP(uint64 instruction, img_address m_pc)
+static std::string SCDP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13163,7 +13163,7 @@ std::string NMD::SCDP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SCE(uint64 instruction, img_address m_pc)
+static std::string SCE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13187,7 +13187,7 @@ std::string NMD::SCE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SCWP(uint64 instruction, img_address m_pc)
+static std::string SCWP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13211,7 +13211,7 @@ std::string NMD::SCWP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SCWPE(uint64 instruction, img_address m_pc)
+static std::string SCWPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13235,7 +13235,7 @@ std::string NMD::SCWPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SD_GP_(uint64 instruction, img_address m_pc)
+static std::string SD_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_3__s3(instruction);
@@ -13257,7 +13257,7 @@ std::string NMD::SD_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SD_S9_(uint64 instruction, img_address m_pc)
+static std::string SD_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13281,7 +13281,7 @@ std::string NMD::SD_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SD_U12_(uint64 instruction, img_address m_pc)
+static std::string SD_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13305,7 +13305,7 @@ std::string NMD::SD_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDBBP_16_(uint64 instruction, img_address m_pc)
+static std::string SDBBP_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
@@ -13325,7 +13325,7 @@ std::string NMD::SDBBP_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDBBP_32_(uint64 instruction, img_address m_pc)
+static std::string SDBBP_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
@@ -13345,7 +13345,7 @@ std::string NMD::SDBBP_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC1_GP_(uint64 instruction, img_address m_pc)
+static std::string SDC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
@@ -13367,7 +13367,7 @@ std::string NMD::SDC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC1_S9_(uint64 instruction, img_address m_pc)
+static std::string SDC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13391,7 +13391,7 @@ std::string NMD::SDC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC1_U12_(uint64 instruction, img_address m_pc)
+static std::string SDC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13415,7 +13415,7 @@ std::string NMD::SDC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC1X(uint64 instruction, img_address m_pc)
+static std::string SDC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13439,7 +13439,7 @@ std::string NMD::SDC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC1XS(uint64 instruction, img_address m_pc)
+static std::string SDC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13463,7 +13463,7 @@ std::string NMD::SDC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDC2(uint64 instruction, img_address m_pc)
+static std::string SDC2(uint64 instruction, img_address m_pc)
 {
     uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13487,7 +13487,7 @@ std::string NMD::SDC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDM(uint64 instruction, img_address m_pc)
+static std::string SDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13513,7 +13513,7 @@ std::string NMD::SDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDPC_48_(uint64 instruction, img_address m_pc)
+static std::string SDPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -13535,7 +13535,7 @@ std::string NMD::SDPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDXS(uint64 instruction, img_address m_pc)
+static std::string SDXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13559,7 +13559,7 @@ std::string NMD::SDXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SDX(uint64 instruction, img_address m_pc)
+static std::string SDX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13583,7 +13583,7 @@ std::string NMD::SDX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SEB(uint64 instruction, img_address m_pc)
+static std::string SEB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13605,7 +13605,7 @@ std::string NMD::SEB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SEH(uint64 instruction, img_address m_pc)
+static std::string SEH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13627,7 +13627,7 @@ std::string NMD::SEH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SEL_D(uint64 instruction, img_address m_pc)
+static std::string SEL_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13651,7 +13651,7 @@ std::string NMD::SEL_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SEL_S(uint64 instruction, img_address m_pc)
+static std::string SEL_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13675,7 +13675,7 @@ std::string NMD::SEL_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SELEQZ_D(uint64 instruction, img_address m_pc)
+static std::string SELEQZ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13699,7 +13699,7 @@ std::string NMD::SELEQZ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SELEQZ_S(uint64 instruction, img_address m_pc)
+static std::string SELEQZ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13723,7 +13723,7 @@ std::string NMD::SELEQZ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SELNEZ_D(uint64 instruction, img_address m_pc)
+static std::string SELNEZ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13747,7 +13747,7 @@ std::string NMD::SELNEZ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SELNEZ_S(uint64 instruction, img_address m_pc)
+static std::string SELNEZ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -13771,7 +13771,7 @@ std::string NMD::SELNEZ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SEQI(uint64 instruction, img_address m_pc)
+static std::string SEQI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13795,7 +13795,7 @@ std::string NMD::SEQI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SH_16_(uint64 instruction, img_address m_pc)
+static std::string SH_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -13819,7 +13819,7 @@ std::string NMD::SH_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SH_GP_(uint64 instruction, img_address m_pc)
+static std::string SH_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
@@ -13841,7 +13841,7 @@ std::string NMD::SH_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SH_S9_(uint64 instruction, img_address m_pc)
+static std::string SH_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13865,7 +13865,7 @@ std::string NMD::SH_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SH_U12_(uint64 instruction, img_address m_pc)
+static std::string SH_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13889,7 +13889,7 @@ std::string NMD::SH_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHE(uint64 instruction, img_address m_pc)
+static std::string SHE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13913,7 +13913,7 @@ std::string NMD::SHE(uint64 instruction, img_address m_pc)
  *      shift ------
  *               ac --
  */
-std::string NMD::SHILO(uint64 instruction, img_address m_pc)
+static std::string SHILO(uint64 instruction, img_address m_pc)
 {
     int64 shift_value = extract_shift__se5_21_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -13935,7 +13935,7 @@ std::string NMD::SHILO(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-std::string NMD::SHILOV(uint64 instruction, img_address m_pc)
+static std::string SHILOV(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
@@ -13957,7 +13957,7 @@ std::string NMD::SHILOV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ----
  */
-std::string NMD::SHLL_PH(uint64 instruction, img_address m_pc)
+static std::string SHLL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13981,7 +13981,7 @@ std::string NMD::SHLL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ---
  */
-std::string NMD::SHLL_QB(uint64 instruction, img_address m_pc)
+static std::string SHLL_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14006,7 +14006,7 @@ std::string NMD::SHLL_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ----
  */
-std::string NMD::SHLL_S_PH(uint64 instruction, img_address m_pc)
+static std::string SHLL_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14030,7 +14030,7 @@ std::string NMD::SHLL_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa -----
  */
-std::string NMD::SHLL_S_W(uint64 instruction, img_address m_pc)
+static std::string SHLL_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14055,7 +14055,7 @@ std::string NMD::SHLL_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHLLV_PH(uint64 instruction, img_address m_pc)
+static std::string SHLLV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14079,7 +14079,7 @@ std::string NMD::SHLLV_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHLLV_QB(uint64 instruction, img_address m_pc)
+static std::string SHLLV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14104,7 +14104,7 @@ std::string NMD::SHLLV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHLLV_S_PH(uint64 instruction, img_address m_pc)
+static std::string SHLLV_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14128,7 +14128,7 @@ std::string NMD::SHLLV_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHLLV_S_W(uint64 instruction, img_address m_pc)
+static std::string SHLLV_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14152,7 +14152,7 @@ std::string NMD::SHLLV_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRA_PH(uint64 instruction, img_address m_pc)
+static std::string SHRA_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14176,7 +14176,7 @@ std::string NMD::SHRA_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRA_QB(uint64 instruction, img_address m_pc)
+static std::string SHRA_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14200,7 +14200,7 @@ std::string NMD::SHRA_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRA_R_PH(uint64 instruction, img_address m_pc)
+static std::string SHRA_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14224,7 +14224,7 @@ std::string NMD::SHRA_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRA_R_QB(uint64 instruction, img_address m_pc)
+static std::string SHRA_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14248,7 +14248,7 @@ std::string NMD::SHRA_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRA_R_W(uint64 instruction, img_address m_pc)
+static std::string SHRA_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14272,7 +14272,7 @@ std::string NMD::SHRA_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRAV_PH(uint64 instruction, img_address m_pc)
+static std::string SHRAV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14296,7 +14296,7 @@ std::string NMD::SHRAV_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRAV_QB(uint64 instruction, img_address m_pc)
+static std::string SHRAV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14320,7 +14320,7 @@ std::string NMD::SHRAV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRAV_R_PH(uint64 instruction, img_address m_pc)
+static std::string SHRAV_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14344,7 +14344,7 @@ std::string NMD::SHRAV_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRAV_R_QB(uint64 instruction, img_address m_pc)
+static std::string SHRAV_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14368,7 +14368,7 @@ std::string NMD::SHRAV_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRAV_R_W(uint64 instruction, img_address m_pc)
+static std::string SHRAV_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14392,7 +14392,7 @@ std::string NMD::SHRAV_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ----
  */
-std::string NMD::SHRL_PH(uint64 instruction, img_address m_pc)
+static std::string SHRL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14416,7 +14416,7 @@ std::string NMD::SHRL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ---
  */
-std::string NMD::SHRL_QB(uint64 instruction, img_address m_pc)
+static std::string SHRL_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14441,7 +14441,7 @@ std::string NMD::SHRL_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRLV_PH(uint64 instruction, img_address m_pc)
+static std::string SHRLV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14465,7 +14465,7 @@ std::string NMD::SHRLV_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHRLV_QB(uint64 instruction, img_address m_pc)
+static std::string SHRLV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14489,7 +14489,7 @@ std::string NMD::SHRLV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHX(uint64 instruction, img_address m_pc)
+static std::string SHX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14513,7 +14513,7 @@ std::string NMD::SHX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SHXS(uint64 instruction, img_address m_pc)
+static std::string SHXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14537,7 +14537,7 @@ std::string NMD::SHXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SIGRIE(uint64 instruction, img_address m_pc)
+static std::string SIGRIE(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
@@ -14557,7 +14557,7 @@ std::string NMD::SIGRIE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLL_16_(uint64 instruction, img_address m_pc)
+static std::string SLL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -14581,7 +14581,7 @@ std::string NMD::SLL_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLL_32_(uint64 instruction, img_address m_pc)
+static std::string SLL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14605,7 +14605,7 @@ std::string NMD::SLL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLLV(uint64 instruction, img_address m_pc)
+static std::string SLLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14629,7 +14629,7 @@ std::string NMD::SLLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLT(uint64 instruction, img_address m_pc)
+static std::string SLT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14653,7 +14653,7 @@ std::string NMD::SLT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLTI(uint64 instruction, img_address m_pc)
+static std::string SLTI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14677,7 +14677,7 @@ std::string NMD::SLTI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLTIU(uint64 instruction, img_address m_pc)
+static std::string SLTIU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14701,7 +14701,7 @@ std::string NMD::SLTIU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SLTU(uint64 instruction, img_address m_pc)
+static std::string SLTU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14725,7 +14725,7 @@ std::string NMD::SLTU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SOV(uint64 instruction, img_address m_pc)
+static std::string SOV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14749,7 +14749,7 @@ std::string NMD::SOV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SPECIAL2(uint64 instruction, img_address m_pc)
+static std::string SPECIAL2(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
@@ -14769,7 +14769,7 @@ std::string NMD::SPECIAL2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SQRT_D(uint64 instruction, img_address m_pc)
+static std::string SQRT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -14791,7 +14791,7 @@ std::string NMD::SQRT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SQRT_S(uint64 instruction, img_address m_pc)
+static std::string SQRT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -14813,7 +14813,7 @@ std::string NMD::SQRT_S(uint64 instruction, img_address m_pc)
  *               rd -----
  *                    sa -----
  */
-std::string NMD::SRA(uint64 instruction, img_address m_pc)
+static std::string SRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14837,7 +14837,7 @@ std::string NMD::SRA(uint64 instruction, img_address m_pc)
  *          rt -----
  *               rd -----
  */
-std::string NMD::SRAV(uint64 instruction, img_address m_pc)
+static std::string SRAV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14861,7 +14861,7 @@ std::string NMD::SRAV(uint64 instruction, img_address m_pc)
  *          rt -----
  *               rd -----
  */
-std::string NMD::SRL_16_(uint64 instruction, img_address m_pc)
+static std::string SRL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -14885,7 +14885,7 @@ std::string NMD::SRL_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SRL_32_(uint64 instruction, img_address m_pc)
+static std::string SRL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14909,7 +14909,7 @@ std::string NMD::SRL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SRLV(uint64 instruction, img_address m_pc)
+static std::string SRLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14933,7 +14933,7 @@ std::string NMD::SRLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUB(uint64 instruction, img_address m_pc)
+static std::string SUB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -14957,7 +14957,7 @@ std::string NMD::SUB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUB_D(uint64 instruction, img_address m_pc)
+static std::string SUB_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -14981,7 +14981,7 @@ std::string NMD::SUB_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUB_S(uint64 instruction, img_address m_pc)
+static std::string SUB_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -15005,7 +15005,7 @@ std::string NMD::SUB_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQ_PH(uint64 instruction, img_address m_pc)
+static std::string SUBQ_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15030,7 +15030,7 @@ std::string NMD::SUBQ_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQ_S_PH(uint64 instruction, img_address m_pc)
+static std::string SUBQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15055,7 +15055,7 @@ std::string NMD::SUBQ_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQ_S_W(uint64 instruction, img_address m_pc)
+static std::string SUBQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15080,7 +15080,7 @@ std::string NMD::SUBQ_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQH_PH(uint64 instruction, img_address m_pc)
+static std::string SUBQH_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15105,7 +15105,7 @@ std::string NMD::SUBQH_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQH_R_PH(uint64 instruction, img_address m_pc)
+static std::string SUBQH_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15130,7 +15130,7 @@ std::string NMD::SUBQH_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQH_R_W(uint64 instruction, img_address m_pc)
+static std::string SUBQH_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15155,7 +15155,7 @@ std::string NMD::SUBQH_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBQH_W(uint64 instruction, img_address m_pc)
+static std::string SUBQH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15179,7 +15179,7 @@ std::string NMD::SUBQH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_16_(uint64 instruction, img_address m_pc)
+static std::string SUBU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -15203,7 +15203,7 @@ std::string NMD::SUBU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_32_(uint64 instruction, img_address m_pc)
+static std::string SUBU_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15227,7 +15227,7 @@ std::string NMD::SUBU_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_PH(uint64 instruction, img_address m_pc)
+static std::string SUBU_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15251,7 +15251,7 @@ std::string NMD::SUBU_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_QB(uint64 instruction, img_address m_pc)
+static std::string SUBU_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15276,7 +15276,7 @@ std::string NMD::SUBU_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_S_PH(uint64 instruction, img_address m_pc)
+static std::string SUBU_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15301,7 +15301,7 @@ std::string NMD::SUBU_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBU_S_QB(uint64 instruction, img_address m_pc)
+static std::string SUBU_S_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15326,7 +15326,7 @@ std::string NMD::SUBU_S_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBUH_QB(uint64 instruction, img_address m_pc)
+static std::string SUBUH_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15351,7 +15351,7 @@ std::string NMD::SUBUH_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SUBUH_R_QB(uint64 instruction, img_address m_pc)
+static std::string SUBUH_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15375,7 +15375,7 @@ std::string NMD::SUBUH_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_16_(uint64 instruction, img_address m_pc)
+static std::string SW_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -15399,7 +15399,7 @@ std::string NMD::SW_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_4X4_(uint64 instruction, img_address m_pc)
+static std::string SW_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
@@ -15423,7 +15423,7 @@ std::string NMD::SW_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_GP16_(uint64 instruction, img_address m_pc)
+static std::string SW_GP16_(uint64 instruction, img_address m_pc)
 {
     uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
@@ -15445,7 +15445,7 @@ std::string NMD::SW_GP16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_GP_(uint64 instruction, img_address m_pc)
+static std::string SW_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
@@ -15467,7 +15467,7 @@ std::string NMD::SW_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_S9_(uint64 instruction, img_address m_pc)
+static std::string SW_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
@@ -15491,7 +15491,7 @@ std::string NMD::SW_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_SP_(uint64 instruction, img_address m_pc)
+static std::string SW_SP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
@@ -15513,7 +15513,7 @@ std::string NMD::SW_SP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SW_U12_(uint64 instruction, img_address m_pc)
+static std::string SW_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15537,7 +15537,7 @@ std::string NMD::SW_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC1_GP_(uint64 instruction, img_address m_pc)
+static std::string SWC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
@@ -15559,7 +15559,7 @@ std::string NMD::SWC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC1_S9_(uint64 instruction, img_address m_pc)
+static std::string SWC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15583,7 +15583,7 @@ std::string NMD::SWC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC1_U12_(uint64 instruction, img_address m_pc)
+static std::string SWC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15607,7 +15607,7 @@ std::string NMD::SWC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC1X(uint64 instruction, img_address m_pc)
+static std::string SWC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15631,7 +15631,7 @@ std::string NMD::SWC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC1XS(uint64 instruction, img_address m_pc)
+static std::string SWC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15655,7 +15655,7 @@ std::string NMD::SWC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWC2(uint64 instruction, img_address m_pc)
+static std::string SWC2(uint64 instruction, img_address m_pc)
 {
     uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15679,7 +15679,7 @@ std::string NMD::SWC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWE(uint64 instruction, img_address m_pc)
+static std::string SWE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15703,7 +15703,7 @@ std::string NMD::SWE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWM(uint64 instruction, img_address m_pc)
+static std::string SWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15729,7 +15729,7 @@ std::string NMD::SWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWPC_48_(uint64 instruction, img_address m_pc)
+static std::string SWPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
@@ -15751,7 +15751,7 @@ std::string NMD::SWPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWX(uint64 instruction, img_address m_pc)
+static std::string SWX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15775,7 +15775,7 @@ std::string NMD::SWX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SWXS(uint64 instruction, img_address m_pc)
+static std::string SWXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15799,7 +15799,7 @@ std::string NMD::SWXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SYNC(uint64 instruction, img_address m_pc)
+static std::string SYNC(uint64 instruction, img_address m_pc)
 {
     uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
 
@@ -15819,7 +15819,7 @@ std::string NMD::SYNC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SYNCI(uint64 instruction, img_address m_pc)
+static std::string SYNCI(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
@@ -15841,7 +15841,7 @@ std::string NMD::SYNCI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SYNCIE(uint64 instruction, img_address m_pc)
+static std::string SYNCIE(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
@@ -15863,7 +15863,7 @@ std::string NMD::SYNCIE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::SYSCALL_16_(uint64 instruction, img_address m_pc)
+static std::string SYSCALL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
@@ -15881,7 +15881,7 @@ std::string NMD::SYSCALL_16_(uint64 instruction, img_address m_pc)
  *  00000000000010
  *           code ------------------
  */
-std::string NMD::SYSCALL_32_(uint64 instruction, img_address m_pc)
+static std::string SYSCALL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
@@ -15901,7 +15901,7 @@ std::string NMD::SYSCALL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TEQ(uint64 instruction, img_address m_pc)
+static std::string TEQ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15923,7 +15923,7 @@ std::string NMD::TEQ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGINV(uint64 instruction, img_address m_pc)
+static std::string TLBGINV(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -15941,7 +15941,7 @@ std::string NMD::TLBGINV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGINVF(uint64 instruction, img_address m_pc)
+static std::string TLBGINVF(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -15959,7 +15959,7 @@ std::string NMD::TLBGINVF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGP(uint64 instruction, img_address m_pc)
+static std::string TLBGP(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -15977,7 +15977,7 @@ std::string NMD::TLBGP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGR(uint64 instruction, img_address m_pc)
+static std::string TLBGR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -15995,7 +15995,7 @@ std::string NMD::TLBGR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGWI(uint64 instruction, img_address m_pc)
+static std::string TLBGWI(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16013,7 +16013,7 @@ std::string NMD::TLBGWI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBGWR(uint64 instruction, img_address m_pc)
+static std::string TLBGWR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16031,7 +16031,7 @@ std::string NMD::TLBGWR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBINV(uint64 instruction, img_address m_pc)
+static std::string TLBINV(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16049,7 +16049,7 @@ std::string NMD::TLBINV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBINVF(uint64 instruction, img_address m_pc)
+static std::string TLBINVF(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16067,7 +16067,7 @@ std::string NMD::TLBINVF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBP(uint64 instruction, img_address m_pc)
+static std::string TLBP(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16085,7 +16085,7 @@ std::string NMD::TLBP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBR(uint64 instruction, img_address m_pc)
+static std::string TLBR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16103,7 +16103,7 @@ std::string NMD::TLBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBWI(uint64 instruction, img_address m_pc)
+static std::string TLBWI(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16121,7 +16121,7 @@ std::string NMD::TLBWI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TLBWR(uint64 instruction, img_address m_pc)
+static std::string TLBWR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
@@ -16139,7 +16139,7 @@ std::string NMD::TLBWR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TNE(uint64 instruction, img_address m_pc)
+static std::string TNE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16161,7 +16161,7 @@ std::string NMD::TNE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TRUNC_L_D(uint64 instruction, img_address m_pc)
+static std::string TRUNC_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -16183,7 +16183,7 @@ std::string NMD::TRUNC_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TRUNC_L_S(uint64 instruction, img_address m_pc)
+static std::string TRUNC_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -16205,7 +16205,7 @@ std::string NMD::TRUNC_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TRUNC_W_D(uint64 instruction, img_address m_pc)
+static std::string TRUNC_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -16227,7 +16227,7 @@ std::string NMD::TRUNC_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::TRUNC_W_S(uint64 instruction, img_address m_pc)
+static std::string TRUNC_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
@@ -16249,7 +16249,7 @@ std::string NMD::TRUNC_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UALDM(uint64 instruction, img_address m_pc)
+static std::string UALDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16275,7 +16275,7 @@ std::string NMD::UALDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UALH(uint64 instruction, img_address m_pc)
+static std::string UALH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16299,7 +16299,7 @@ std::string NMD::UALH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UALWM(uint64 instruction, img_address m_pc)
+static std::string UALWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16325,7 +16325,7 @@ std::string NMD::UALWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UASDM(uint64 instruction, img_address m_pc)
+static std::string UASDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16351,7 +16351,7 @@ std::string NMD::UASDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UASH(uint64 instruction, img_address m_pc)
+static std::string UASH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16375,7 +16375,7 @@ std::string NMD::UASH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UASWM(uint64 instruction, img_address m_pc)
+static std::string UASWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16401,7 +16401,7 @@ std::string NMD::UASWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::UDI(uint64 instruction, img_address m_pc)
+static std::string UDI(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
@@ -16419,7 +16419,7 @@ std::string NMD::UDI(uint64 instruction, img_address m_pc)
  *  001000          1100001101111111
  *   code ----------
  */
-std::string NMD::WAIT(uint64 instruction, img_address m_pc)
+static std::string WAIT(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
 
@@ -16439,7 +16439,7 @@ std::string NMD::WAIT(uint64 instruction, img_address m_pc)
  *     rt -----
  *        mask -------
  */
-std::string NMD::WRDSP(uint64 instruction, img_address m_pc)
+static std::string WRDSP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
@@ -16461,7 +16461,7 @@ std::string NMD::WRDSP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::WRPGPR(uint64 instruction, img_address m_pc)
+static std::string WRPGPR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16483,7 +16483,7 @@ std::string NMD::WRPGPR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::XOR_16_(uint64 instruction, img_address m_pc)
+static std::string XOR_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
@@ -16505,7 +16505,7 @@ std::string NMD::XOR_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::XOR_32_(uint64 instruction, img_address m_pc)
+static std::string XOR_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16529,7 +16529,7 @@ std::string NMD::XOR_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-std::string NMD::XORI(uint64 instruction, img_address m_pc)
+static std::string XORI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16552,7 +16552,7 @@ std::string NMD::XORI(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-std::string NMD::YIELD(uint64 instruction, img_address m_pc)
+static std::string YIELD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -16669,26 +16669,26 @@ std::string NMD::YIELD(uint64 instruction, img_address m_pc)
 
 NMD::Pool NMD::P_SYSCALL[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfffc0000, 0x00080000, &NMD::SYSCALL_32_      , 0,
+       0xfffc0000, 0x00080000, &SYSCALL_32_      , 0,
        0x0                 },        /* SYSCALL[32] */
     { instruction         , 0                   , 0   , 32,
-       0xfffc0000, 0x000c0000, &NMD::HYPCALL          , 0,
+       0xfffc0000, 0x000c0000, &HYPCALL          , 0,
        CP0_ | VZ_          },        /* HYPCALL */
 };
 
 
 NMD::Pool NMD::P_RI[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfff80000, 0x00000000, &NMD::SIGRIE           , 0,
+       0xfff80000, 0x00000000, &SIGRIE           , 0,
        0x0                 },        /* SIGRIE */
     { pool                , P_SYSCALL           , 2   , 32,
        0xfff80000, 0x00080000, 0                      , 0,
        0x0                 },        /* P.SYSCALL */
     { instruction         , 0                   , 0   , 32,
-       0xfff80000, 0x00100000, &NMD::BREAK_32_        , 0,
+       0xfff80000, 0x00100000, &BREAK_32_        , 0,
        0x0                 },        /* BREAK[32] */
     { instruction         , 0                   , 0   , 32,
-       0xfff80000, 0x00180000, &NMD::SDBBP_32_        , 0,
+       0xfff80000, 0x00180000, &SDBBP_32_        , 0,
        EJTAG_              },        /* SDBBP[32] */
 };
 
@@ -16698,47 +16698,47 @@ NMD::Pool NMD::P_ADDIU[2] = {
        0xffe00000, 0x00000000, 0                      , 0,
        0x0                 },        /* P.RI */
     { instruction         , 0                   , 0   , 32,
-       0xfc000000, 0x00000000, &NMD::ADDIU_32_        , &ADDIU_32__cond   ,
+       0xfc000000, 0x00000000, &ADDIU_32_        , &ADDIU_32__cond   ,
        0x0                 },        /* ADDIU[32] */
 };
 
 
 NMD::Pool NMD::P_TRAP[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000000, &NMD::TEQ              , 0,
+       0xfc0007ff, 0x20000000, &TEQ              , 0,
        XMMS_               },        /* TEQ */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000400, &NMD::TNE              , 0,
+       0xfc0007ff, 0x20000400, &TNE              , 0,
        XMMS_               },        /* TNE */
 };
 
 
 NMD::Pool NMD::P_CMOVE[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000210, &NMD::MOVZ             , 0,
+       0xfc0007ff, 0x20000210, &MOVZ             , 0,
        0x0                 },        /* MOVZ */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000610, &NMD::MOVN             , 0,
+       0xfc0007ff, 0x20000610, &MOVN             , 0,
        0x0                 },        /* MOVN */
 };
 
 
 NMD::Pool NMD::P_D_MT_VPE[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc1f3fff, 0x20010ab0, &NMD::DMT              , 0,
+       0xfc1f3fff, 0x20010ab0, &DMT              , 0,
        MT_                 },        /* DMT */
     { instruction         , 0                   , 0   , 32,
-       0xfc1f3fff, 0x20000ab0, &NMD::DVPE             , 0,
+       0xfc1f3fff, 0x20000ab0, &DVPE             , 0,
        MT_                 },        /* DVPE */
 };
 
 
 NMD::Pool NMD::P_E_MT_VPE[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc1f3fff, 0x20010eb0, &NMD::EMT              , 0,
+       0xfc1f3fff, 0x20010eb0, &EMT              , 0,
        MT_                 },        /* EMT */
     { instruction         , 0                   , 0   , 32,
-       0xfc1f3fff, 0x20000eb0, &NMD::EVPE             , 0,
+       0xfc1f3fff, 0x20000eb0, &EVPE             , 0,
        MT_                 },        /* EVPE */
 };
 
@@ -16783,10 +16783,10 @@ NMD::Pool NMD::P_MT_VPE[8] = {
 
 NMD::Pool NMD::P_DVP[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x20000390, &NMD::DVP              , 0,
+       0xfc00ffff, 0x20000390, &DVP              , 0,
        0x0                 },        /* DVP */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x20000790, &NMD::EVP              , 0,
+       0xfc00ffff, 0x20000790, &EVP              , 0,
        0x0                 },        /* EVP */
 };
 
@@ -16796,7 +16796,7 @@ NMD::Pool NMD::P_SLTU[2] = {
        0xfc00fbff, 0x20000390, 0                      , 0,
        0x0                 },        /* P.DVP */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000390, &NMD::SLTU             , &SLTU_cond        ,
+       0xfc0003ff, 0x20000390, &SLTU             , &SLTU_cond        ,
        0x0                 },        /* SLTU */
 };
 
@@ -16806,13 +16806,13 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000000, 0                      , 0,
        0x0                 },        /* P.TRAP */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000008, &NMD::SEB              , 0,
+       0xfc0003ff, 0x20000008, &SEB              , 0,
        XMMS_               },        /* SEB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000010, &NMD::SLLV             , 0,
+       0xfc0003ff, 0x20000010, &SLLV             , 0,
        0x0                 },        /* SLLV */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000018, &NMD::MUL_32_          , 0,
+       0xfc0003ff, 0x20000018, &MUL_32_          , 0,
        0x0                 },        /* MUL[32] */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000020, 0                      , 0,
@@ -16821,22 +16821,22 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000028, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(5) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000030, &NMD::MFC0             , 0,
+       0xfc0003ff, 0x20000030, &MFC0             , 0,
        0x0                 },        /* MFC0 */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000038, &NMD::MFHC0            , 0,
+       0xfc0003ff, 0x20000038, &MFHC0            , 0,
        CP0_ | MVH_         },        /* MFHC0 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000040, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(8) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000048, &NMD::SEH              , 0,
+       0xfc0003ff, 0x20000048, &SEH              , 0,
        0x0                 },        /* SEH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000050, &NMD::SRLV             , 0,
+       0xfc0003ff, 0x20000050, &SRLV             , 0,
        0x0                 },        /* SRLV */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000058, &NMD::MUH              , 0,
+       0xfc0003ff, 0x20000058, &MUH              , 0,
        0x0                 },        /* MUH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000060, 0                      , 0,
@@ -16845,10 +16845,10 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000068, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(13) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000070, &NMD::MTC0             , 0,
+       0xfc0003ff, 0x20000070, &MTC0             , 0,
        CP0_                },        /* MTC0 */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000078, &NMD::MTHC0            , 0,
+       0xfc0003ff, 0x20000078, &MTHC0            , 0,
        CP0_ | MVH_         },        /* MTHC0 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000080, 0                      , 0,
@@ -16857,10 +16857,10 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000088, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(17) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000090, &NMD::SRAV             , 0,
+       0xfc0003ff, 0x20000090, &SRAV             , 0,
        0x0                 },        /* SRAV */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000098, &NMD::MULU             , 0,
+       0xfc0003ff, 0x20000098, &MULU             , 0,
        0x0                 },        /* MULU */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200000a0, 0                      , 0,
@@ -16869,10 +16869,10 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x200000a8, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(21) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200000b0, &NMD::MFGC0            , 0,
+       0xfc0003ff, 0x200000b0, &MFGC0            , 0,
        CP0_ | VZ_          },        /* MFGC0 */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200000b8, &NMD::MFHGC0           , 0,
+       0xfc0003ff, 0x200000b8, &MFHGC0           , 0,
        CP0_ | VZ_ | MVH_   },        /* MFHGC0 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200000c0, 0                      , 0,
@@ -16881,10 +16881,10 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x200000c8, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(25) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200000d0, &NMD::ROTRV            , 0,
+       0xfc0003ff, 0x200000d0, &ROTRV            , 0,
        0x0                 },        /* ROTRV */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200000d8, &NMD::MUHU             , 0,
+       0xfc0003ff, 0x200000d8, &MUHU             , 0,
        0x0                 },        /* MUHU */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200000e0, 0                      , 0,
@@ -16893,10 +16893,10 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x200000e8, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(29) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200000f0, &NMD::MTGC0            , 0,
+       0xfc0003ff, 0x200000f0, &MTGC0            , 0,
        CP0_ | VZ_          },        /* MTGC0 */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200000f8, &NMD::MTHGC0           , 0,
+       0xfc0003ff, 0x200000f8, &MTHGC0           , 0,
        CP0_ | VZ_ | MVH_   },        /* MTHGC0 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000100, 0                      , 0,
@@ -16905,10 +16905,10 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000108, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(33) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000110, &NMD::ADD              , 0,
+       0xfc0003ff, 0x20000110, &ADD              , 0,
        XMMS_               },        /* ADD */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000118, &NMD::DIV              , 0,
+       0xfc0003ff, 0x20000118, &DIV              , 0,
        0x0                 },        /* DIV */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000120, 0                      , 0,
@@ -16917,7 +16917,7 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000128, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(37) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000130, &NMD::DMFC0            , 0,
+       0xfc0003ff, 0x20000130, &DMFC0            , 0,
        CP0_ | MIPS64_      },        /* DMFC0 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000138, 0                      , 0,
@@ -16929,10 +16929,10 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000148, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(41) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000150, &NMD::ADDU_32_         , 0,
+       0xfc0003ff, 0x20000150, &ADDU_32_         , 0,
        0x0                 },        /* ADDU[32] */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000158, &NMD::MOD              , 0,
+       0xfc0003ff, 0x20000158, &MOD              , 0,
        0x0                 },        /* MOD */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000160, 0                      , 0,
@@ -16941,7 +16941,7 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000168, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(45) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000170, &NMD::DMTC0            , 0,
+       0xfc0003ff, 0x20000170, &DMTC0            , 0,
        CP0_ | MIPS64_      },        /* DMTC0 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000178, 0                      , 0,
@@ -16953,10 +16953,10 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000188, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(49) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000190, &NMD::SUB              , 0,
+       0xfc0003ff, 0x20000190, &SUB              , 0,
        XMMS_               },        /* SUB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000198, &NMD::DIVU             , 0,
+       0xfc0003ff, 0x20000198, &DIVU             , 0,
        0x0                 },        /* DIVU */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200001a0, 0                      , 0,
@@ -16965,22 +16965,22 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x200001a8, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(53) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200001b0, &NMD::DMFGC0           , 0,
+       0xfc0003ff, 0x200001b0, &DMFGC0           , 0,
        CP0_ | MIPS64_ | VZ_},        /* DMFGC0 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200001b8, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(55) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200001c0, &NMD::RDHWR            , 0,
+       0xfc0003ff, 0x200001c0, &RDHWR            , 0,
        XMMS_               },        /* RDHWR */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200001c8, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(57) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200001d0, &NMD::SUBU_32_         , 0,
+       0xfc0003ff, 0x200001d0, &SUBU_32_         , 0,
        0x0                 },        /* SUBU[32] */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200001d8, &NMD::MODU             , 0,
+       0xfc0003ff, 0x200001d8, &MODU             , 0,
        0x0                 },        /* MODU */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200001e0, 0                      , 0,
@@ -16989,7 +16989,7 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x200001e8, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(61) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200001f0, &NMD::DMTGC0           , 0,
+       0xfc0003ff, 0x200001f0, &DMTGC0           , 0,
        CP0_ | MIPS64_ | VZ_},        /* DMTGC0 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200001f8, 0                      , 0,
@@ -17010,13 +17010,13 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000220, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(68) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000228, &NMD::FORK             , 0,
+       0xfc0003ff, 0x20000228, &FORK             , 0,
        MT_                 },        /* FORK */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000230, &NMD::MFTR             , 0,
+       0xfc0003ff, 0x20000230, &MFTR             , 0,
        MT_                 },        /* MFTR */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000238, &NMD::MFHTR            , 0,
+       0xfc0003ff, 0x20000238, &MFHTR            , 0,
        MT_                 },        /* MFHTR */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000240, 0                      , 0,
@@ -17025,7 +17025,7 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000248, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(73) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000250, &NMD::AND_32_          , 0,
+       0xfc0003ff, 0x20000250, &AND_32_          , 0,
        0x0                 },        /* AND[32] */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000258, 0                      , 0,
@@ -17034,13 +17034,13 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000260, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(76) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000268, &NMD::YIELD            , 0,
+       0xfc0003ff, 0x20000268, &YIELD            , 0,
        MT_                 },        /* YIELD */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000270, &NMD::MTTR             , 0,
+       0xfc0003ff, 0x20000270, &MTTR             , 0,
        MT_                 },        /* MTTR */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000278, &NMD::MTHTR            , 0,
+       0xfc0003ff, 0x20000278, &MTHTR            , 0,
        MT_                 },        /* MTHTR */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000280, 0                      , 0,
@@ -17049,7 +17049,7 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000288, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(81) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000290, &NMD::OR_32_           , 0,
+       0xfc0003ff, 0x20000290, &OR_32_           , 0,
        0x0                 },        /* OR[32] */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000298, 0                      , 0,
@@ -17073,7 +17073,7 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x200002c8, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(89) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200002d0, &NMD::NOR              , 0,
+       0xfc0003ff, 0x200002d0, &NOR              , 0,
        0x0                 },        /* NOR */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200002d8, 0                      , 0,
@@ -17097,7 +17097,7 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000308, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(97) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000310, &NMD::XOR_32_          , 0,
+       0xfc0003ff, 0x20000310, &XOR_32_          , 0,
        0x0                 },        /* XOR[32] */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000318, 0                      , 0,
@@ -17121,7 +17121,7 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x20000348, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(105) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000350, &NMD::SLT              , 0,
+       0xfc0003ff, 0x20000350, &SLT              , 0,
        0x0                 },        /* SLT */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000358, 0                      , 0,
@@ -17169,7 +17169,7 @@ NMD::Pool NMD::_POOL32A0[128] = {
        0xfc0003ff, 0x200003c8, 0                      , 0,
        0x0                 },        /* _POOL32A0~*(121) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200003d0, &NMD::SOV              , 0,
+       0xfc0003ff, 0x200003d0, &SOV              , 0,
        0x0                 },        /* SOV */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200003d8, 0                      , 0,
@@ -17191,183 +17191,183 @@ NMD::Pool NMD::_POOL32A0[128] = {
 
 NMD::Pool NMD::ADDQ__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000000d, &NMD::ADDQ_PH          , 0,
+       0xfc0007ff, 0x2000000d, &ADDQ_PH          , 0,
        DSP_                },        /* ADDQ.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000040d, &NMD::ADDQ_S_PH        , 0,
+       0xfc0007ff, 0x2000040d, &ADDQ_S_PH        , 0,
        DSP_                },        /* ADDQ_S.PH */
 };
 
 
 NMD::Pool NMD::MUL__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000002d, &NMD::MUL_PH           , 0,
+       0xfc0007ff, 0x2000002d, &MUL_PH           , 0,
        DSP_                },        /* MUL.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000042d, &NMD::MUL_S_PH         , 0,
+       0xfc0007ff, 0x2000042d, &MUL_S_PH         , 0,
        DSP_                },        /* MUL_S.PH */
 };
 
 
 NMD::Pool NMD::ADDQH__R__PH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000004d, &NMD::ADDQH_PH         , 0,
+       0xfc0007ff, 0x2000004d, &ADDQH_PH         , 0,
        DSP_                },        /* ADDQH.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000044d, &NMD::ADDQH_R_PH       , 0,
+       0xfc0007ff, 0x2000044d, &ADDQH_R_PH       , 0,
        DSP_                },        /* ADDQH_R.PH */
 };
 
 
 NMD::Pool NMD::ADDQH__R__W[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000008d, &NMD::ADDQH_W          , 0,
+       0xfc0007ff, 0x2000008d, &ADDQH_W          , 0,
        DSP_                },        /* ADDQH.W */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000048d, &NMD::ADDQH_R_W        , 0,
+       0xfc0007ff, 0x2000048d, &ADDQH_R_W        , 0,
        DSP_                },        /* ADDQH_R.W */
 };
 
 
 NMD::Pool NMD::ADDU__S__QB[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200000cd, &NMD::ADDU_QB          , 0,
+       0xfc0007ff, 0x200000cd, &ADDU_QB          , 0,
        DSP_                },        /* ADDU.QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200004cd, &NMD::ADDU_S_QB        , 0,
+       0xfc0007ff, 0x200004cd, &ADDU_S_QB        , 0,
        DSP_                },        /* ADDU_S.QB */
 };
 
 
 NMD::Pool NMD::ADDU__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000010d, &NMD::ADDU_PH          , 0,
+       0xfc0007ff, 0x2000010d, &ADDU_PH          , 0,
        DSP_                },        /* ADDU.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000050d, &NMD::ADDU_S_PH        , 0,
+       0xfc0007ff, 0x2000050d, &ADDU_S_PH        , 0,
        DSP_                },        /* ADDU_S.PH */
 };
 
 
 NMD::Pool NMD::ADDUH__R__QB[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000014d, &NMD::ADDUH_QB         , 0,
+       0xfc0007ff, 0x2000014d, &ADDUH_QB         , 0,
        DSP_                },        /* ADDUH.QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000054d, &NMD::ADDUH_R_QB       , 0,
+       0xfc0007ff, 0x2000054d, &ADDUH_R_QB       , 0,
        DSP_                },        /* ADDUH_R.QB */
 };
 
 
 NMD::Pool NMD::SHRAV__R__PH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000018d, &NMD::SHRAV_PH         , 0,
+       0xfc0007ff, 0x2000018d, &SHRAV_PH         , 0,
        DSP_                },        /* SHRAV.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000058d, &NMD::SHRAV_R_PH       , 0,
+       0xfc0007ff, 0x2000058d, &SHRAV_R_PH       , 0,
        DSP_                },        /* SHRAV_R.PH */
 };
 
 
 NMD::Pool NMD::SHRAV__R__QB[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200001cd, &NMD::SHRAV_QB         , 0,
+       0xfc0007ff, 0x200001cd, &SHRAV_QB         , 0,
        DSP_                },        /* SHRAV.QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200005cd, &NMD::SHRAV_R_QB       , 0,
+       0xfc0007ff, 0x200005cd, &SHRAV_R_QB       , 0,
        DSP_                },        /* SHRAV_R.QB */
 };
 
 
 NMD::Pool NMD::SUBQ__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000020d, &NMD::SUBQ_PH          , 0,
+       0xfc0007ff, 0x2000020d, &SUBQ_PH          , 0,
        DSP_                },        /* SUBQ.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000060d, &NMD::SUBQ_S_PH        , 0,
+       0xfc0007ff, 0x2000060d, &SUBQ_S_PH        , 0,
        DSP_                },        /* SUBQ_S.PH */
 };
 
 
 NMD::Pool NMD::SUBQH__R__PH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000024d, &NMD::SUBQH_PH         , 0,
+       0xfc0007ff, 0x2000024d, &SUBQH_PH         , 0,
        DSP_                },        /* SUBQH.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000064d, &NMD::SUBQH_R_PH       , 0,
+       0xfc0007ff, 0x2000064d, &SUBQH_R_PH       , 0,
        DSP_                },        /* SUBQH_R.PH */
 };
 
 
 NMD::Pool NMD::SUBQH__R__W[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000028d, &NMD::SUBQH_W          , 0,
+       0xfc0007ff, 0x2000028d, &SUBQH_W          , 0,
        DSP_                },        /* SUBQH.W */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000068d, &NMD::SUBQH_R_W        , 0,
+       0xfc0007ff, 0x2000068d, &SUBQH_R_W        , 0,
        DSP_                },        /* SUBQH_R.W */
 };
 
 
 NMD::Pool NMD::SUBU__S__QB[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200002cd, &NMD::SUBU_QB          , 0,
+       0xfc0007ff, 0x200002cd, &SUBU_QB          , 0,
        DSP_                },        /* SUBU.QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200006cd, &NMD::SUBU_S_QB        , 0,
+       0xfc0007ff, 0x200006cd, &SUBU_S_QB        , 0,
        DSP_                },        /* SUBU_S.QB */
 };
 
 
 NMD::Pool NMD::SUBU__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000030d, &NMD::SUBU_PH          , 0,
+       0xfc0007ff, 0x2000030d, &SUBU_PH          , 0,
        DSP_                },        /* SUBU.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000070d, &NMD::SUBU_S_PH        , 0,
+       0xfc0007ff, 0x2000070d, &SUBU_S_PH        , 0,
        DSP_                },        /* SUBU_S.PH */
 };
 
 
 NMD::Pool NMD::SHRA__R__PH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000335, &NMD::SHRA_PH          , 0,
+       0xfc0007ff, 0x20000335, &SHRA_PH          , 0,
        DSP_                },        /* SHRA.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000735, &NMD::SHRA_R_PH        , 0,
+       0xfc0007ff, 0x20000735, &SHRA_R_PH        , 0,
        DSP_                },        /* SHRA_R.PH */
 };
 
 
 NMD::Pool NMD::SUBUH__R__QB[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000034d, &NMD::SUBUH_QB         , 0,
+       0xfc0007ff, 0x2000034d, &SUBUH_QB         , 0,
        DSP_                },        /* SUBUH.QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000074d, &NMD::SUBUH_R_QB       , 0,
+       0xfc0007ff, 0x2000074d, &SUBUH_R_QB       , 0,
        DSP_                },        /* SUBUH_R.QB */
 };
 
 
 NMD::Pool NMD::SHLLV__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000038d, &NMD::SHLLV_PH         , 0,
+       0xfc0007ff, 0x2000038d, &SHLLV_PH         , 0,
        DSP_                },        /* SHLLV.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x2000078d, &NMD::SHLLV_S_PH       , 0,
+       0xfc0007ff, 0x2000078d, &SHLLV_S_PH       , 0,
        DSP_                },        /* SHLLV_S.PH */
 };
 
 
 NMD::Pool NMD::SHLL__S__PH[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc000fff, 0x200003b5, &NMD::SHLL_PH          , 0,
+       0xfc000fff, 0x200003b5, &SHLL_PH          , 0,
        DSP_                },        /* SHLL.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc000fff, 0x200007b5, 0                      , 0,
        0x0                 },        /* SHLL[_S].PH~*(1) */
     { instruction         , 0                   , 0   , 32,
-       0xfc000fff, 0x20000bb5, &NMD::SHLL_S_PH        , 0,
+       0xfc000fff, 0x20000bb5, &SHLL_S_PH        , 0,
        DSP_                },        /* SHLL_S.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc000fff, 0x20000fb5, 0                      , 0,
@@ -17377,17 +17377,17 @@ NMD::Pool NMD::SHLL__S__PH[4] = {
 
 NMD::Pool NMD::PRECR_SRA__R__PH_W[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200003cd, &NMD::PRECR_SRA_PH_W   , 0,
+       0xfc0007ff, 0x200003cd, &PRECR_SRA_PH_W   , 0,
        DSP_                },        /* PRECR_SRA.PH.W */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200007cd, &NMD::PRECR_SRA_R_PH_W , 0,
+       0xfc0007ff, 0x200007cd, &PRECR_SRA_R_PH_W , 0,
        DSP_                },        /* PRECR_SRA_R.PH.W */
 };
 
 
 NMD::Pool NMD::_POOL32A5[128] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000005, &NMD::CMP_EQ_PH        , 0,
+       0xfc0003ff, 0x20000005, &CMP_EQ_PH        , 0,
        DSP_                },        /* CMP.EQ.PH */
     { pool                , ADDQ__S__PH         , 2   , 32,
        0xfc0003ff, 0x2000000d, 0                      , 0,
@@ -17396,10 +17396,10 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x20000015, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(2) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x2000001d, &NMD::SHILO            , 0,
+       0xfc0003ff, 0x2000001d, &SHILO            , 0,
        DSP_                },        /* SHILO */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000025, &NMD::MULEQ_S_W_PHL    , 0,
+       0xfc0003ff, 0x20000025, &MULEQ_S_W_PHL    , 0,
        DSP_                },        /* MULEQ_S.W.PHL */
     { pool                , MUL__S__PH          , 2   , 32,
        0xfc0003ff, 0x2000002d, 0                      , 0,
@@ -17408,10 +17408,10 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x20000035, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(6) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x2000003d, &NMD::REPL_PH          , 0,
+       0xfc0003ff, 0x2000003d, &REPL_PH          , 0,
        DSP_                },        /* REPL.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000045, &NMD::CMP_LT_PH        , 0,
+       0xfc0003ff, 0x20000045, &CMP_LT_PH        , 0,
        DSP_                },        /* CMP.LT.PH */
     { pool                , ADDQH__R__PH        , 2   , 32,
        0xfc0003ff, 0x2000004d, 0                      , 0,
@@ -17423,10 +17423,10 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x2000005d, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(11) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000065, &NMD::MULEQ_S_W_PHR    , 0,
+       0xfc0003ff, 0x20000065, &MULEQ_S_W_PHR    , 0,
        DSP_                },        /* MULEQ_S.W.PHR */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x2000006d, &NMD::PRECR_QB_PH      , 0,
+       0xfc0003ff, 0x2000006d, &PRECR_QB_PH      , 0,
        DSP_                },        /* PRECR.QB.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000075, 0                      , 0,
@@ -17435,13 +17435,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x2000007d, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(15) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000085, &NMD::CMP_LE_PH        , 0,
+       0xfc0003ff, 0x20000085, &CMP_LE_PH        , 0,
        DSP_                },        /* CMP.LE.PH */
     { pool                , ADDQH__R__W         , 2   , 32,
        0xfc0003ff, 0x2000008d, 0                      , 0,
        0x0                 },        /* ADDQH[_R].W */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000095, &NMD::MULEU_S_PH_QBL   , 0,
+       0xfc0003ff, 0x20000095, &MULEU_S_PH_QBL   , 0,
        DSP_                },        /* MULEU_S.PH.QBL */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x2000009d, 0                      , 0,
@@ -17450,7 +17450,7 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200000a5, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(20) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200000ad, &NMD::PRECRQ_QB_PH     , 0,
+       0xfc0003ff, 0x200000ad, &PRECRQ_QB_PH     , 0,
        DSP_                },        /* PRECRQ.QB.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200000b5, 0                      , 0,
@@ -17459,13 +17459,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200000bd, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(23) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200000c5, &NMD::CMPGU_EQ_QB      , 0,
+       0xfc0003ff, 0x200000c5, &CMPGU_EQ_QB      , 0,
        DSP_                },        /* CMPGU.EQ.QB */
     { pool                , ADDU__S__QB         , 2   , 32,
        0xfc0003ff, 0x200000cd, 0                      , 0,
        0x0                 },        /* ADDU[_S].QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200000d5, &NMD::MULEU_S_PH_QBR   , 0,
+       0xfc0003ff, 0x200000d5, &MULEU_S_PH_QBR   , 0,
        DSP_                },        /* MULEU_S.PH.QBR */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200000dd, 0                      , 0,
@@ -17474,7 +17474,7 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200000e5, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(28) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200000ed, &NMD::PRECRQ_PH_W      , 0,
+       0xfc0003ff, 0x200000ed, &PRECRQ_PH_W      , 0,
        DSP_                },        /* PRECRQ.PH.W */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200000f5, 0                      , 0,
@@ -17483,13 +17483,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200000fd, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(31) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000105, &NMD::CMPGU_LT_QB      , 0,
+       0xfc0003ff, 0x20000105, &CMPGU_LT_QB      , 0,
        DSP_                },        /* CMPGU.LT.QB */
     { pool                , ADDU__S__PH         , 2   , 32,
        0xfc0003ff, 0x2000010d, 0                      , 0,
        0x0                 },        /* ADDU[_S].PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000115, &NMD::MULQ_RS_PH       , 0,
+       0xfc0003ff, 0x20000115, &MULQ_RS_PH       , 0,
        DSP_                },        /* MULQ_RS.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x2000011d, 0                      , 0,
@@ -17498,7 +17498,7 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x20000125, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(36) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x2000012d, &NMD::PRECRQ_RS_PH_W   , 0,
+       0xfc0003ff, 0x2000012d, &PRECRQ_RS_PH_W   , 0,
        DSP_                },        /* PRECRQ_RS.PH.W */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000135, 0                      , 0,
@@ -17507,13 +17507,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x2000013d, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(39) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000145, &NMD::CMPGU_LE_QB      , 0,
+       0xfc0003ff, 0x20000145, &CMPGU_LE_QB      , 0,
        DSP_                },        /* CMPGU.LE.QB */
     { pool                , ADDUH__R__QB        , 2   , 32,
        0xfc0003ff, 0x2000014d, 0                      , 0,
        0x0                 },        /* ADDUH[_R].QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000155, &NMD::MULQ_S_PH        , 0,
+       0xfc0003ff, 0x20000155, &MULQ_S_PH        , 0,
        DSP_                },        /* MULQ_S.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x2000015d, 0                      , 0,
@@ -17522,7 +17522,7 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x20000165, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(44) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x2000016d, &NMD::PRECRQU_S_QB_PH  , 0,
+       0xfc0003ff, 0x2000016d, &PRECRQU_S_QB_PH  , 0,
        DSP_                },        /* PRECRQU_S.QB.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000175, 0                      , 0,
@@ -17531,13 +17531,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x2000017d, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(47) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000185, &NMD::CMPGDU_EQ_QB     , 0,
+       0xfc0003ff, 0x20000185, &CMPGDU_EQ_QB     , 0,
        DSP_                },        /* CMPGDU.EQ.QB */
     { pool                , SHRAV__R__PH        , 2   , 32,
        0xfc0003ff, 0x2000018d, 0                      , 0,
        0x0                 },        /* SHRAV[_R].PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000195, &NMD::MULQ_RS_W        , 0,
+       0xfc0003ff, 0x20000195, &MULQ_RS_W        , 0,
        DSP_                },        /* MULQ_RS.W */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x2000019d, 0                      , 0,
@@ -17546,7 +17546,7 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200001a5, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(52) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200001ad, &NMD::PACKRL_PH        , 0,
+       0xfc0003ff, 0x200001ad, &PACKRL_PH        , 0,
        DSP_                },        /* PACKRL.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200001b5, 0                      , 0,
@@ -17555,13 +17555,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200001bd, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(55) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200001c5, &NMD::CMPGDU_LT_QB     , 0,
+       0xfc0003ff, 0x200001c5, &CMPGDU_LT_QB     , 0,
        DSP_                },        /* CMPGDU.LT.QB */
     { pool                , SHRAV__R__QB        , 2   , 32,
        0xfc0003ff, 0x200001cd, 0                      , 0,
        0x0                 },        /* SHRAV[_R].QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200001d5, &NMD::MULQ_S_W         , 0,
+       0xfc0003ff, 0x200001d5, &MULQ_S_W         , 0,
        DSP_                },        /* MULQ_S.W */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200001dd, 0                      , 0,
@@ -17570,7 +17570,7 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200001e5, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(60) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200001ed, &NMD::PICK_QB          , 0,
+       0xfc0003ff, 0x200001ed, &PICK_QB          , 0,
        DSP_                },        /* PICK.QB */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200001f5, 0                      , 0,
@@ -17579,13 +17579,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200001fd, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(63) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000205, &NMD::CMPGDU_LE_QB     , 0,
+       0xfc0003ff, 0x20000205, &CMPGDU_LE_QB     , 0,
        DSP_                },        /* CMPGDU.LE.QB */
     { pool                , SUBQ__S__PH         , 2   , 32,
        0xfc0003ff, 0x2000020d, 0                      , 0,
        0x0                 },        /* SUBQ[_S].PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000215, &NMD::APPEND           , 0,
+       0xfc0003ff, 0x20000215, &APPEND           , 0,
        DSP_                },        /* APPEND */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x2000021d, 0                      , 0,
@@ -17594,7 +17594,7 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x20000225, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(68) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x2000022d, &NMD::PICK_PH          , 0,
+       0xfc0003ff, 0x2000022d, &PICK_PH          , 0,
        DSP_                },        /* PICK.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x20000235, 0                      , 0,
@@ -17603,13 +17603,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x2000023d, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(71) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000245, &NMD::CMPU_EQ_QB       , 0,
+       0xfc0003ff, 0x20000245, &CMPU_EQ_QB       , 0,
        DSP_                },        /* CMPU.EQ.QB */
     { pool                , SUBQH__R__PH        , 2   , 32,
        0xfc0003ff, 0x2000024d, 0                      , 0,
        0x0                 },        /* SUBQH[_R].PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000255, &NMD::PREPEND          , 0,
+       0xfc0003ff, 0x20000255, &PREPEND          , 0,
        DSP_                },        /* PREPEND */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x2000025d, 0                      , 0,
@@ -17627,13 +17627,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x2000027d, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(79) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000285, &NMD::CMPU_LT_QB       , 0,
+       0xfc0003ff, 0x20000285, &CMPU_LT_QB       , 0,
        DSP_                },        /* CMPU.LT.QB */
     { pool                , SUBQH__R__W         , 2   , 32,
        0xfc0003ff, 0x2000028d, 0                      , 0,
        0x0                 },        /* SUBQH[_R].W */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000295, &NMD::MODSUB           , 0,
+       0xfc0003ff, 0x20000295, &MODSUB           , 0,
        DSP_                },        /* MODSUB */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x2000029d, 0                      , 0,
@@ -17651,13 +17651,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200002bd, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(87) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200002c5, &NMD::CMPU_LE_QB       , 0,
+       0xfc0003ff, 0x200002c5, &CMPU_LE_QB       , 0,
        DSP_                },        /* CMPU.LE.QB */
     { pool                , SUBU__S__QB         , 2   , 32,
        0xfc0003ff, 0x200002cd, 0                      , 0,
        0x0                 },        /* SUBU[_S].QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200002d5, &NMD::SHRAV_R_W        , 0,
+       0xfc0003ff, 0x200002d5, &SHRAV_R_W        , 0,
        DSP_                },        /* SHRAV_R.W */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200002dd, 0                      , 0,
@@ -17669,19 +17669,19 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200002ed, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(93) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200002f5, &NMD::SHRA_R_W         , 0,
+       0xfc0003ff, 0x200002f5, &SHRA_R_W         , 0,
        DSP_                },        /* SHRA_R.W */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200002fd, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(95) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000305, &NMD::ADDQ_S_W         , 0,
+       0xfc0003ff, 0x20000305, &ADDQ_S_W         , 0,
        DSP_                },        /* ADDQ_S.W */
     { pool                , SUBU__S__PH         , 2   , 32,
        0xfc0003ff, 0x2000030d, 0                      , 0,
        0x0                 },        /* SUBU[_S].PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000315, &NMD::SHRLV_PH         , 0,
+       0xfc0003ff, 0x20000315, &SHRLV_PH         , 0,
        DSP_                },        /* SHRLV.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x2000031d, 0                      , 0,
@@ -17699,13 +17699,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x2000033d, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(103) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000345, &NMD::SUBQ_S_W         , 0,
+       0xfc0003ff, 0x20000345, &SUBQ_S_W         , 0,
        DSP_                },        /* SUBQ_S.W */
     { pool                , SUBUH__R__QB        , 2   , 32,
        0xfc0003ff, 0x2000034d, 0                      , 0,
        0x0                 },        /* SUBUH[_R].QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000355, &NMD::SHRLV_QB         , 0,
+       0xfc0003ff, 0x20000355, &SHRLV_QB         , 0,
        DSP_                },        /* SHRLV.QB */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x2000035d, 0                      , 0,
@@ -17723,13 +17723,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x2000037d, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(111) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000385, &NMD::ADDSC            , 0,
+       0xfc0003ff, 0x20000385, &ADDSC            , 0,
        DSP_                },        /* ADDSC */
     { pool                , SHLLV__S__PH        , 2   , 32,
        0xfc0003ff, 0x2000038d, 0                      , 0,
        0x0                 },        /* SHLLV[_S].PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x20000395, &NMD::SHLLV_QB         , 0,
+       0xfc0003ff, 0x20000395, &SHLLV_QB         , 0,
        DSP_                },        /* SHLLV.QB */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x2000039d, 0                      , 0,
@@ -17747,13 +17747,13 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200003bd, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(119) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200003c5, &NMD::ADDWC            , 0,
+       0xfc0003ff, 0x200003c5, &ADDWC            , 0,
        DSP_                },        /* ADDWC */
     { pool                , PRECR_SRA__R__PH_W  , 2   , 32,
        0xfc0003ff, 0x200003cd, 0                      , 0,
        0x0                 },        /* PRECR_SRA[_R].PH.W */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200003d5, &NMD::SHLLV_S_W        , 0,
+       0xfc0003ff, 0x200003d5, &SHLLV_S_W        , 0,
        DSP_                },        /* SHLLV_S.W */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200003dd, 0                      , 0,
@@ -17765,7 +17765,7 @@ NMD::Pool NMD::_POOL32A5[128] = {
        0xfc0003ff, 0x200003ed, 0                      , 0,
        0x0                 },        /* _POOL32A5~*(125) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0x200003f5, &NMD::SHLL_S_W         , 0,
+       0xfc0003ff, 0x200003f5, &SHLL_S_W         , 0,
        DSP_                },        /* SHLL_S.W */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0x200003fd, 0                      , 0,
@@ -17775,52 +17775,52 @@ NMD::Pool NMD::_POOL32A5[128] = {
 
 NMD::Pool NMD::PP_LSX[16] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000007, &NMD::LBX              , 0,
+       0xfc0007ff, 0x20000007, &LBX              , 0,
        0x0                 },        /* LBX */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000087, &NMD::SBX              , 0,
+       0xfc0007ff, 0x20000087, &SBX              , 0,
        XMMS_               },        /* SBX */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000107, &NMD::LBUX             , 0,
+       0xfc0007ff, 0x20000107, &LBUX             , 0,
        0x0                 },        /* LBUX */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0007ff, 0x20000187, 0                      , 0,
        0x0                 },        /* PP.LSX~*(3) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000207, &NMD::LHX              , 0,
+       0xfc0007ff, 0x20000207, &LHX              , 0,
        0x0                 },        /* LHX */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000287, &NMD::SHX              , 0,
+       0xfc0007ff, 0x20000287, &SHX              , 0,
        XMMS_               },        /* SHX */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000307, &NMD::LHUX             , 0,
+       0xfc0007ff, 0x20000307, &LHUX             , 0,
        0x0                 },        /* LHUX */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000387, &NMD::LWUX             , 0,
+       0xfc0007ff, 0x20000387, &LWUX             , 0,
        MIPS64_             },        /* LWUX */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000407, &NMD::LWX              , 0,
+       0xfc0007ff, 0x20000407, &LWX              , 0,
        0x0                 },        /* LWX */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000487, &NMD::SWX              , 0,
+       0xfc0007ff, 0x20000487, &SWX              , 0,
        XMMS_               },        /* SWX */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000507, &NMD::LWC1X            , 0,
+       0xfc0007ff, 0x20000507, &LWC1X            , 0,
        CP1_                },        /* LWC1X */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000587, &NMD::SWC1X            , 0,
+       0xfc0007ff, 0x20000587, &SWC1X            , 0,
        CP1_                },        /* SWC1X */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000607, &NMD::LDX              , 0,
+       0xfc0007ff, 0x20000607, &LDX              , 0,
        MIPS64_             },        /* LDX */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000687, &NMD::SDX              , 0,
+       0xfc0007ff, 0x20000687, &SDX              , 0,
        MIPS64_             },        /* SDX */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000707, &NMD::LDC1X            , 0,
+       0xfc0007ff, 0x20000707, &LDC1X            , 0,
        CP1_                },        /* LDC1X */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000787, &NMD::SDC1X            , 0,
+       0xfc0007ff, 0x20000787, &SDC1X            , 0,
        CP1_                },        /* SDC1X */
 };
 
@@ -17839,40 +17839,40 @@ NMD::Pool NMD::PP_LSXS[16] = {
        0xfc0007ff, 0x200001c7, 0                      , 0,
        0x0                 },        /* PP.LSXS~*(3) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000247, &NMD::LHXS             , 0,
+       0xfc0007ff, 0x20000247, &LHXS             , 0,
        0x0                 },        /* LHXS */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200002c7, &NMD::SHXS             , 0,
+       0xfc0007ff, 0x200002c7, &SHXS             , 0,
        XMMS_               },        /* SHXS */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000347, &NMD::LHUXS            , 0,
+       0xfc0007ff, 0x20000347, &LHUXS            , 0,
        0x0                 },        /* LHUXS */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200003c7, &NMD::LWUXS            , 0,
+       0xfc0007ff, 0x200003c7, &LWUXS            , 0,
        MIPS64_             },        /* LWUXS */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000447, &NMD::LWXS_32_         , 0,
+       0xfc0007ff, 0x20000447, &LWXS_32_         , 0,
        0x0                 },        /* LWXS[32] */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200004c7, &NMD::SWXS             , 0,
+       0xfc0007ff, 0x200004c7, &SWXS             , 0,
        XMMS_               },        /* SWXS */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000547, &NMD::LWC1XS           , 0,
+       0xfc0007ff, 0x20000547, &LWC1XS           , 0,
        CP1_                },        /* LWC1XS */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200005c7, &NMD::SWC1XS           , 0,
+       0xfc0007ff, 0x200005c7, &SWC1XS           , 0,
        CP1_                },        /* SWC1XS */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000647, &NMD::LDXS             , 0,
+       0xfc0007ff, 0x20000647, &LDXS             , 0,
        MIPS64_             },        /* LDXS */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200006c7, &NMD::SDXS             , 0,
+       0xfc0007ff, 0x200006c7, &SDXS             , 0,
        MIPS64_             },        /* SDXS */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x20000747, &NMD::LDC1XS           , 0,
+       0xfc0007ff, 0x20000747, &LDC1XS           , 0,
        CP1_                },        /* LDC1XS */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0x200007c7, &NMD::SDC1XS           , 0,
+       0xfc0007ff, 0x200007c7, &SDC1XS           , 0,
        CP1_                },        /* SDC1XS */
 };
 
@@ -17889,26 +17889,26 @@ NMD::Pool NMD::P_LSX[2] = {
 
 NMD::Pool NMD::POOL32Axf_1_0[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x2000007f, &NMD::MFHI_DSP_        , 0,
+       0xfc003fff, 0x2000007f, &MFHI_DSP_        , 0,
        DSP_                },        /* MFHI[DSP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x2000107f, &NMD::MFLO_DSP_        , 0,
+       0xfc003fff, 0x2000107f, &MFLO_DSP_        , 0,
        DSP_                },        /* MFLO[DSP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x2000207f, &NMD::MTHI_DSP_        , 0,
+       0xfc003fff, 0x2000207f, &MTHI_DSP_        , 0,
        DSP_                },        /* MTHI[DSP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x2000307f, &NMD::MTLO_DSP_        , 0,
+       0xfc003fff, 0x2000307f, &MTLO_DSP_        , 0,
        DSP_                },        /* MTLO[DSP] */
 };
 
 
 NMD::Pool NMD::POOL32Axf_1_1[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x2000027f, &NMD::MTHLIP           , 0,
+       0xfc003fff, 0x2000027f, &MTHLIP           , 0,
        DSP_                },        /* MTHLIP */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x2000127f, &NMD::SHILOV           , 0,
+       0xfc003fff, 0x2000127f, &SHILOV           , 0,
        DSP_                },        /* SHILOV */
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0x2000227f, 0                      , 0,
@@ -17921,46 +17921,46 @@ NMD::Pool NMD::POOL32Axf_1_1[4] = {
 
 NMD::Pool NMD::POOL32Axf_1_3[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x2000067f, &NMD::RDDSP            , 0,
+       0xfc003fff, 0x2000067f, &RDDSP            , 0,
        DSP_                },        /* RDDSP */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x2000167f, &NMD::WRDSP            , 0,
+       0xfc003fff, 0x2000167f, &WRDSP            , 0,
        DSP_                },        /* WRDSP */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x2000267f, &NMD::EXTP             , 0,
+       0xfc003fff, 0x2000267f, &EXTP             , 0,
        DSP_                },        /* EXTP */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x2000367f, &NMD::EXTPDP           , 0,
+       0xfc003fff, 0x2000367f, &EXTPDP           , 0,
        DSP_                },        /* EXTPDP */
 };
 
 
 NMD::Pool NMD::POOL32Axf_1_4[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc001fff, 0x2000087f, &NMD::SHLL_QB          , 0,
+       0xfc001fff, 0x2000087f, &SHLL_QB          , 0,
        DSP_                },        /* SHLL.QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc001fff, 0x2000187f, &NMD::SHRL_QB          , 0,
+       0xfc001fff, 0x2000187f, &SHRL_QB          , 0,
        DSP_                },        /* SHRL.QB */
 };
 
 
 NMD::Pool NMD::MAQ_S_A__W_PHR[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20000a7f, &NMD::MAQ_S_W_PHR      , 0,
+       0xfc003fff, 0x20000a7f, &MAQ_S_W_PHR      , 0,
        DSP_                },        /* MAQ_S.W.PHR */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20002a7f, &NMD::MAQ_SA_W_PHR     , 0,
+       0xfc003fff, 0x20002a7f, &MAQ_SA_W_PHR     , 0,
        DSP_                },        /* MAQ_SA.W.PHR */
 };
 
 
 NMD::Pool NMD::MAQ_S_A__W_PHL[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20001a7f, &NMD::MAQ_S_W_PHL      , 0,
+       0xfc003fff, 0x20001a7f, &MAQ_S_W_PHL      , 0,
        DSP_                },        /* MAQ_S.W.PHL */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20003a7f, &NMD::MAQ_SA_W_PHL     , 0,
+       0xfc003fff, 0x20003a7f, &MAQ_SA_W_PHL     , 0,
        DSP_                },        /* MAQ_SA.W.PHL */
 };
 
@@ -17977,16 +17977,16 @@ NMD::Pool NMD::POOL32Axf_1_5[2] = {
 
 NMD::Pool NMD::POOL32Axf_1_7[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20000e7f, &NMD::EXTR_W           , 0,
+       0xfc003fff, 0x20000e7f, &EXTR_W           , 0,
        DSP_                },        /* EXTR.W */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20001e7f, &NMD::EXTR_R_W         , 0,
+       0xfc003fff, 0x20001e7f, &EXTR_R_W         , 0,
        DSP_                },        /* EXTR_R.W */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20002e7f, &NMD::EXTR_RS_W        , 0,
+       0xfc003fff, 0x20002e7f, &EXTR_RS_W        , 0,
        DSP_                },        /* EXTR_RS.W */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20003e7f, &NMD::EXTR_S_H         , 0,
+       0xfc003fff, 0x20003e7f, &EXTR_S_H         , 0,
        DSP_                },        /* EXTR_S.H */
 };
 
@@ -18021,112 +18021,112 @@ NMD::Pool NMD::POOL32Axf_1[8] = {
 
 NMD::Pool NMD::POOL32Axf_2_DSP__0_7[8] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200000bf, &NMD::DPA_W_PH         , 0,
+       0xfc003fff, 0x200000bf, &DPA_W_PH         , 0,
        DSP_                },        /* DPA.W.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200002bf, &NMD::DPAQ_S_W_PH      , 0,
+       0xfc003fff, 0x200002bf, &DPAQ_S_W_PH      , 0,
        DSP_                },        /* DPAQ_S.W.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200004bf, &NMD::DPS_W_PH         , 0,
+       0xfc003fff, 0x200004bf, &DPS_W_PH         , 0,
        DSP_                },        /* DPS.W.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200006bf, &NMD::DPSQ_S_W_PH      , 0,
+       0xfc003fff, 0x200006bf, &DPSQ_S_W_PH      , 0,
        DSP_                },        /* DPSQ_S.W.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0x200008bf, 0                      , 0,
        0x0                 },        /* POOL32Axf_2(DSP)_0_7~*(4) */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20000abf, &NMD::MADD_DSP_        , 0,
+       0xfc003fff, 0x20000abf, &MADD_DSP_        , 0,
        DSP_                },        /* MADD[DSP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20000cbf, &NMD::MULT_DSP_        , 0,
+       0xfc003fff, 0x20000cbf, &MULT_DSP_        , 0,
        DSP_                },        /* MULT[DSP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20000ebf, &NMD::EXTRV_W          , 0,
+       0xfc003fff, 0x20000ebf, &EXTRV_W          , 0,
        DSP_                },        /* EXTRV.W */
 };
 
 
 NMD::Pool NMD::POOL32Axf_2_DSP__8_15[8] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200010bf, &NMD::DPAX_W_PH        , 0,
+       0xfc003fff, 0x200010bf, &DPAX_W_PH        , 0,
        DSP_                },        /* DPAX.W.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200012bf, &NMD::DPAQ_SA_L_W      , 0,
+       0xfc003fff, 0x200012bf, &DPAQ_SA_L_W      , 0,
        DSP_                },        /* DPAQ_SA.L.W */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200014bf, &NMD::DPSX_W_PH        , 0,
+       0xfc003fff, 0x200014bf, &DPSX_W_PH        , 0,
        DSP_                },        /* DPSX.W.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200016bf, &NMD::DPSQ_SA_L_W      , 0,
+       0xfc003fff, 0x200016bf, &DPSQ_SA_L_W      , 0,
        DSP_                },        /* DPSQ_SA.L.W */
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0x200018bf, 0                      , 0,
        0x0                 },        /* POOL32Axf_2(DSP)_8_15~*(4) */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20001abf, &NMD::MADDU_DSP_       , 0,
+       0xfc003fff, 0x20001abf, &MADDU_DSP_       , 0,
        DSP_                },        /* MADDU[DSP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20001cbf, &NMD::MULTU_DSP_       , 0,
+       0xfc003fff, 0x20001cbf, &MULTU_DSP_       , 0,
        DSP_                },        /* MULTU[DSP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20001ebf, &NMD::EXTRV_R_W        , 0,
+       0xfc003fff, 0x20001ebf, &EXTRV_R_W        , 0,
        DSP_                },        /* EXTRV_R.W */
 };
 
 
 NMD::Pool NMD::POOL32Axf_2_DSP__16_23[8] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200020bf, &NMD::DPAU_H_QBL       , 0,
+       0xfc003fff, 0x200020bf, &DPAU_H_QBL       , 0,
        DSP_                },        /* DPAU.H.QBL */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200022bf, &NMD::DPAQX_S_W_PH     , 0,
+       0xfc003fff, 0x200022bf, &DPAQX_S_W_PH     , 0,
        DSP_                },        /* DPAQX_S.W.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200024bf, &NMD::DPSU_H_QBL       , 0,
+       0xfc003fff, 0x200024bf, &DPSU_H_QBL       , 0,
        DSP_                },        /* DPSU.H.QBL */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200026bf, &NMD::DPSQX_S_W_PH     , 0,
+       0xfc003fff, 0x200026bf, &DPSQX_S_W_PH     , 0,
        DSP_                },        /* DPSQX_S.W.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200028bf, &NMD::EXTPV            , 0,
+       0xfc003fff, 0x200028bf, &EXTPV            , 0,
        DSP_                },        /* EXTPV */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20002abf, &NMD::MSUB_DSP_        , 0,
+       0xfc003fff, 0x20002abf, &MSUB_DSP_        , 0,
        DSP_                },        /* MSUB[DSP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20002cbf, &NMD::MULSA_W_PH       , 0,
+       0xfc003fff, 0x20002cbf, &MULSA_W_PH       , 0,
        DSP_                },        /* MULSA.W.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20002ebf, &NMD::EXTRV_RS_W       , 0,
+       0xfc003fff, 0x20002ebf, &EXTRV_RS_W       , 0,
        DSP_                },        /* EXTRV_RS.W */
 };
 
 
 NMD::Pool NMD::POOL32Axf_2_DSP__24_31[8] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200030bf, &NMD::DPAU_H_QBR       , 0,
+       0xfc003fff, 0x200030bf, &DPAU_H_QBR       , 0,
        DSP_                },        /* DPAU.H.QBR */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200032bf, &NMD::DPAQX_SA_W_PH    , 0,
+       0xfc003fff, 0x200032bf, &DPAQX_SA_W_PH    , 0,
        DSP_                },        /* DPAQX_SA.W.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200034bf, &NMD::DPSU_H_QBR       , 0,
+       0xfc003fff, 0x200034bf, &DPSU_H_QBR       , 0,
        DSP_                },        /* DPSU.H.QBR */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200036bf, &NMD::DPSQX_SA_W_PH    , 0,
+       0xfc003fff, 0x200036bf, &DPSQX_SA_W_PH    , 0,
        DSP_                },        /* DPSQX_SA.W.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x200038bf, &NMD::EXTPDPV          , 0,
+       0xfc003fff, 0x200038bf, &EXTPDPV          , 0,
        DSP_                },        /* EXTPDPV */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20003abf, &NMD::MSUBU_DSP_       , 0,
+       0xfc003fff, 0x20003abf, &MSUBU_DSP_       , 0,
        DSP_                },        /* MSUBU[DSP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20003cbf, &NMD::MULSAQ_S_W_PH    , 0,
+       0xfc003fff, 0x20003cbf, &MULSAQ_S_W_PH    , 0,
        DSP_                },        /* MULSAQ_S.W.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0x20003ebf, &NMD::EXTRV_S_H        , 0,
+       0xfc003fff, 0x20003ebf, &EXTRV_S_H        , 0,
        DSP_                },        /* EXTRV_S.H */
 };
 
@@ -18149,10 +18149,10 @@ NMD::Pool NMD::POOL32Axf_2[4] = {
 
 NMD::Pool NMD::POOL32Axf_4[128] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000013f, &NMD::ABSQ_S_QB        , 0,
+       0xfc00ffff, 0x2000013f, &ABSQ_S_QB        , 0,
        DSP_                },        /* ABSQ_S.QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000033f, &NMD::REPLV_PH         , 0,
+       0xfc00ffff, 0x2000033f, &REPLV_PH         , 0,
        DSP_                },        /* REPLV.PH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000053f, 0                      , 0,
@@ -18173,10 +18173,10 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x20000f3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(7) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000113f, &NMD::ABSQ_S_PH        , 0,
+       0xfc00ffff, 0x2000113f, &ABSQ_S_PH        , 0,
        DSP_                },        /* ABSQ_S.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000133f, &NMD::REPLV_QB         , 0,
+       0xfc00ffff, 0x2000133f, &REPLV_QB         , 0,
        DSP_                },        /* REPLV.QB */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000153f, 0                      , 0,
@@ -18197,7 +18197,7 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x20001f3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(15) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000213f, &NMD::ABSQ_S_W         , 0,
+       0xfc00ffff, 0x2000213f, &ABSQ_S_W         , 0,
        DSP_                },        /* ABSQ_S.W */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000233f, 0                      , 0,
@@ -18245,7 +18245,7 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x20003f3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(31) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000413f, &NMD::INSV             , 0,
+       0xfc00ffff, 0x2000413f, &INSV             , 0,
        DSP_                },        /* INSV */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000433f, 0                      , 0,
@@ -18260,16 +18260,16 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x2000493f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(36) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x20004b3f, &NMD::CLO              , 0,
+       0xfc00ffff, 0x20004b3f, &CLO              , 0,
        XMMS_               },        /* CLO */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x20004d3f, &NMD::MFC2             , 0,
+       0xfc00ffff, 0x20004d3f, &MFC2             , 0,
        CP2_                },        /* MFC2 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x20004f3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(39) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000513f, &NMD::PRECEQ_W_PHL     , 0,
+       0xfc00ffff, 0x2000513f, &PRECEQ_W_PHL     , 0,
        DSP_                },        /* PRECEQ.W.PHL */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000533f, 0                      , 0,
@@ -18284,16 +18284,16 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x2000593f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(44) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x20005b3f, &NMD::CLZ              , 0,
+       0xfc00ffff, 0x20005b3f, &CLZ              , 0,
        XMMS_               },        /* CLZ */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x20005d3f, &NMD::MTC2             , 0,
+       0xfc00ffff, 0x20005d3f, &MTC2             , 0,
        CP2_                },        /* MTC2 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x20005f3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(47) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000613f, &NMD::PRECEQ_W_PHR     , 0,
+       0xfc00ffff, 0x2000613f, &PRECEQ_W_PHR     , 0,
        DSP_                },        /* PRECEQ.W.PHR */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000633f, 0                      , 0,
@@ -18311,16 +18311,16 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x20006b3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(53) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x20006d3f, &NMD::DMFC2            , 0,
+       0xfc00ffff, 0x20006d3f, &DMFC2            , 0,
        CP2_                },        /* DMFC2 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x20006f3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(55) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000713f, &NMD::PRECEQU_PH_QBL   , 0,
+       0xfc00ffff, 0x2000713f, &PRECEQU_PH_QBL   , 0,
        DSP_                },        /* PRECEQU.PH.QBL */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000733f, &NMD::PRECEQU_PH_QBLA  , 0,
+       0xfc00ffff, 0x2000733f, &PRECEQU_PH_QBLA  , 0,
        DSP_                },        /* PRECEQU.PH.QBLA */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000753f, 0                      , 0,
@@ -18335,7 +18335,7 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x20007b3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(61) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x20007d3f, &NMD::DMTC2            , 0,
+       0xfc00ffff, 0x20007d3f, &DMTC2            , 0,
        CP2_                },        /* DMTC2 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x20007f3f, 0                      , 0,
@@ -18359,16 +18359,16 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x20008b3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(69) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x20008d3f, &NMD::MFHC2            , 0,
+       0xfc00ffff, 0x20008d3f, &MFHC2            , 0,
        CP2_                },        /* MFHC2 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x20008f3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(71) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000913f, &NMD::PRECEQU_PH_QBR   , 0,
+       0xfc00ffff, 0x2000913f, &PRECEQU_PH_QBR   , 0,
        DSP_                },        /* PRECEQU.PH.QBR */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000933f, &NMD::PRECEQU_PH_QBRA  , 0,
+       0xfc00ffff, 0x2000933f, &PRECEQU_PH_QBRA  , 0,
        DSP_                },        /* PRECEQU.PH.QBRA */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000953f, 0                      , 0,
@@ -18383,7 +18383,7 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x20009b3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(77) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x20009d3f, &NMD::MTHC2            , 0,
+       0xfc00ffff, 0x20009d3f, &MTHC2            , 0,
        CP2_                },        /* MTHC2 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x20009f3f, 0                      , 0,
@@ -18413,10 +18413,10 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x2000af3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(87) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000b13f, &NMD::PRECEU_PH_QBL    , 0,
+       0xfc00ffff, 0x2000b13f, &PRECEU_PH_QBL    , 0,
        DSP_                },        /* PRECEU.PH.QBL */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000b33f, &NMD::PRECEU_PH_QBLA   , 0,
+       0xfc00ffff, 0x2000b33f, &PRECEU_PH_QBLA   , 0,
        DSP_                },        /* PRECEU.PH.QBLA */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000b53f, 0                      , 0,
@@ -18455,16 +18455,16 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x2000cb3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(101) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000cd3f, &NMD::CFC2             , 0,
+       0xfc00ffff, 0x2000cd3f, &CFC2             , 0,
        CP2_                },        /* CFC2 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000cf3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(103) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000d13f, &NMD::PRECEU_PH_QBR    , 0,
+       0xfc00ffff, 0x2000d13f, &PRECEU_PH_QBR    , 0,
        DSP_                },        /* PRECEU.PH.QBR */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000d33f, &NMD::PRECEU_PH_QBRA   , 0,
+       0xfc00ffff, 0x2000d33f, &PRECEU_PH_QBRA   , 0,
        DSP_                },        /* PRECEU.PH.QBRA */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000d53f, 0                      , 0,
@@ -18479,7 +18479,7 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x2000db3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(109) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000dd3f, &NMD::CTC2             , 0,
+       0xfc00ffff, 0x2000dd3f, &CTC2             , 0,
        CP2_                },        /* CTC2 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000df3f, 0                      , 0,
@@ -18509,7 +18509,7 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
        0xfc00ffff, 0x2000ef3f, 0                      , 0,
        0x0                 },        /* POOL32Axf_4~*(119) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000f13f, &NMD::RADDU_W_QB       , 0,
+       0xfc00ffff, 0x2000f13f, &RADDU_W_QB       , 0,
        DSP_                },        /* RADDU.W.QB */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000f33f, 0                      , 0,
@@ -18537,16 +18537,16 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
 
 NMD::Pool NMD::POOL32Axf_5_group0[32] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000017f, &NMD::TLBGP            , 0,
+       0xfc00ffff, 0x2000017f, &TLBGP            , 0,
        CP0_ | VZ_ | TLB_   },        /* TLBGP */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000037f, &NMD::TLBP             , 0,
+       0xfc00ffff, 0x2000037f, &TLBP             , 0,
        CP0_ | TLB_         },        /* TLBP */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000057f, &NMD::TLBGINV          , 0,
+       0xfc00ffff, 0x2000057f, &TLBGINV          , 0,
        CP0_ | VZ_ | TLB_ | TLBINV_},        /* TLBGINV */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000077f, &NMD::TLBINV           , 0,
+       0xfc00ffff, 0x2000077f, &TLBINV           , 0,
        CP0_ | TLB_ | TLBINV_},        /* TLBINV */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000097f, 0                      , 0,
@@ -18561,16 +18561,16 @@ NMD::Pool NMD::POOL32Axf_5_group0[32] = {
        0xfc00ffff, 0x20000f7f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group0~*(7) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000117f, &NMD::TLBGR            , 0,
+       0xfc00ffff, 0x2000117f, &TLBGR            , 0,
        CP0_ | VZ_ | TLB_   },        /* TLBGR */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000137f, &NMD::TLBR             , 0,
+       0xfc00ffff, 0x2000137f, &TLBR             , 0,
        CP0_ | TLB_         },        /* TLBR */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000157f, &NMD::TLBGINVF         , 0,
+       0xfc00ffff, 0x2000157f, &TLBGINVF         , 0,
        CP0_ | VZ_ | TLB_ | TLBINV_},        /* TLBGINVF */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000177f, &NMD::TLBINVF          , 0,
+       0xfc00ffff, 0x2000177f, &TLBINVF          , 0,
        CP0_ | TLB_ | TLBINV_},        /* TLBINVF */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000197f, 0                      , 0,
@@ -18585,10 +18585,10 @@ NMD::Pool NMD::POOL32Axf_5_group0[32] = {
        0xfc00ffff, 0x20001f7f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group0~*(15) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000217f, &NMD::TLBGWI           , 0,
+       0xfc00ffff, 0x2000217f, &TLBGWI           , 0,
        CP0_ | VZ_ | TLB_   },        /* TLBGWI */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000237f, &NMD::TLBWI            , 0,
+       0xfc00ffff, 0x2000237f, &TLBWI            , 0,
        CP0_ | TLB_         },        /* TLBWI */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000257f, 0                      , 0,
@@ -18609,10 +18609,10 @@ NMD::Pool NMD::POOL32Axf_5_group0[32] = {
        0xfc00ffff, 0x20002f7f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group0~*(23) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000317f, &NMD::TLBGWR           , 0,
+       0xfc00ffff, 0x2000317f, &TLBGWR           , 0,
        CP0_ | VZ_ | TLB_   },        /* TLBGWR */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000337f, &NMD::TLBWR            , 0,
+       0xfc00ffff, 0x2000337f, &TLBWR            , 0,
        CP0_ | TLB_         },        /* TLBWR */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000357f, 0                      , 0,
@@ -18646,7 +18646,7 @@ NMD::Pool NMD::POOL32Axf_5_group1[32] = {
        0xfc00ffff, 0x2000457f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group1~*(2) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000477f, &NMD::DI               , 0,
+       0xfc00ffff, 0x2000477f, &DI               , 0,
        0x0                 },        /* DI */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000497f, 0                      , 0,
@@ -18670,7 +18670,7 @@ NMD::Pool NMD::POOL32Axf_5_group1[32] = {
        0xfc00ffff, 0x2000557f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group1~*(10) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000577f, &NMD::EI               , 0,
+       0xfc00ffff, 0x2000577f, &EI               , 0,
        0x0                 },        /* EI */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000597f, 0                      , 0,
@@ -18737,10 +18737,10 @@ NMD::Pool NMD::POOL32Axf_5_group1[32] = {
 
 NMD::Pool NMD::ERETx[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc01ffff, 0x2000f37f, &NMD::ERET             , 0,
+       0xfc01ffff, 0x2000f37f, &ERET             , 0,
        0x0                 },        /* ERET */
     { instruction         , 0                   , 0   , 32,
-       0xfc01ffff, 0x2001f37f, &NMD::ERETNC           , 0,
+       0xfc01ffff, 0x2001f37f, &ERETNC           , 0,
        0x0                 },        /* ERETNC */
 };
 
@@ -18750,7 +18750,7 @@ NMD::Pool NMD::POOL32Axf_5_group3[32] = {
        0xfc00ffff, 0x2000c17f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group3~*(0) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000c37f, &NMD::WAIT             , 0,
+       0xfc00ffff, 0x2000c37f, &WAIT             , 0,
        0x0                 },        /* WAIT */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000c57f, 0                      , 0,
@@ -18774,7 +18774,7 @@ NMD::Pool NMD::POOL32Axf_5_group3[32] = {
        0xfc00ffff, 0x2000d17f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group3~*(8) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000d37f, &NMD::IRET             , 0,
+       0xfc00ffff, 0x2000d37f, &IRET             , 0,
        MCU_                },        /* IRET */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000d57f, 0                      , 0,
@@ -18795,10 +18795,10 @@ NMD::Pool NMD::POOL32Axf_5_group3[32] = {
        0xfc00ffff, 0x2000df7f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group3~*(15) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000e17f, &NMD::RDPGPR           , 0,
+       0xfc00ffff, 0x2000e17f, &RDPGPR           , 0,
        CP0_                },        /* RDPGPR */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000e37f, &NMD::DERET            , 0,
+       0xfc00ffff, 0x2000e37f, &DERET            , 0,
        EJTAG_              },        /* DERET */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000e57f, 0                      , 0,
@@ -18819,7 +18819,7 @@ NMD::Pool NMD::POOL32Axf_5_group3[32] = {
        0xfc00ffff, 0x2000ef7f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group3~*(23) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0x2000f17f, &NMD::WRPGPR           , 0,
+       0xfc00ffff, 0x2000f17f, &WRPGPR           , 0,
        CP0_                },        /* WRPGPR */
     { pool                , ERETx               , 2   , 32,
        0xfc00ffff, 0x2000f37f, 0                      , 0,
@@ -18863,10 +18863,10 @@ NMD::Pool NMD::POOL32Axf_5[4] = {
 
 NMD::Pool NMD::SHRA__R__QB[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc001fff, 0x200001ff, &NMD::SHRA_QB          , 0,
+       0xfc001fff, 0x200001ff, &SHRA_QB          , 0,
        DSP_                },        /* SHRA.QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc001fff, 0x200011ff, &NMD::SHRA_R_QB        , 0,
+       0xfc001fff, 0x200011ff, &SHRA_R_QB        , 0,
        DSP_                },        /* SHRA_R.QB */
 };
 
@@ -18876,10 +18876,10 @@ NMD::Pool NMD::POOL32Axf_7[8] = {
        0xfc000fff, 0x200001ff, 0                      , 0,
        0x0                 },        /* SHRA[_R].QB */
     { instruction         , 0                   , 0   , 32,
-       0xfc000fff, 0x200003ff, &NMD::SHRL_PH          , 0,
+       0xfc000fff, 0x200003ff, &SHRL_PH          , 0,
        DSP_                },        /* SHRL.PH */
     { instruction         , 0                   , 0   , 32,
-       0xfc000fff, 0x200005ff, &NMD::REPL_QB          , 0,
+       0xfc000fff, 0x200005ff, &REPL_QB          , 0,
        DSP_                },        /* REPL.QB */
     { reserved_block      , 0                   , 0   , 32,
        0xfc000fff, 0x200007ff, 0                      , 0,
@@ -18932,13 +18932,13 @@ NMD::Pool NMD::_POOL32A7[8] = {
        0xfc00003f, 0x20000007, 0                      , 0,
        0x0                 },        /* P.LSX */
     { instruction         , 0                   , 0   , 32,
-       0xfc00003f, 0x2000000f, &NMD::LSA              , 0,
+       0xfc00003f, 0x2000000f, &LSA              , 0,
        0x0                 },        /* LSA */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00003f, 0x20000017, 0                      , 0,
        0x0                 },        /* _POOL32A7~*(2) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00003f, 0x2000001f, &NMD::EXTW             , 0,
+       0xfc00003f, 0x2000001f, &EXTW             , 0,
        0x0                 },        /* EXTW */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00003f, 0x20000027, 0                      , 0,
@@ -18960,13 +18960,13 @@ NMD::Pool NMD::P32A[8] = {
        0xfc000007, 0x20000000, 0                      , 0,
        0x0                 },        /* _POOL32A0 */
     { instruction         , 0                   , 0   , 32,
-       0xfc000007, 0x20000001, &NMD::SPECIAL2         , 0,
+       0xfc000007, 0x20000001, &SPECIAL2         , 0,
        UDI_                },        /* SPECIAL2 */
     { instruction         , 0                   , 0   , 32,
-       0xfc000007, 0x20000002, &NMD::COP2_1           , 0,
+       0xfc000007, 0x20000002, &COP2_1           , 0,
        CP2_                },        /* COP2_1 */
     { instruction         , 0                   , 0   , 32,
-       0xfc000007, 0x20000003, &NMD::UDI              , 0,
+       0xfc000007, 0x20000003, &UDI              , 0,
        UDI_                },        /* UDI */
     { reserved_block      , 0                   , 0   , 32,
        0xfc000007, 0x20000004, 0                      , 0,
@@ -18985,42 +18985,42 @@ NMD::Pool NMD::P32A[8] = {
 
 NMD::Pool NMD::P_GP_D[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc000007, 0x40000001, &NMD::LD_GP_           , 0,
+       0xfc000007, 0x40000001, &LD_GP_           , 0,
        MIPS64_             },        /* LD[GP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc000007, 0x40000005, &NMD::SD_GP_           , 0,
+       0xfc000007, 0x40000005, &SD_GP_           , 0,
        MIPS64_             },        /* SD[GP] */
 };
 
 
 NMD::Pool NMD::P_GP_W[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc000003, 0x40000000, &NMD::ADDIU_GP_W_      , 0,
+       0xfc000003, 0x40000000, &ADDIU_GP_W_      , 0,
        0x0                 },        /* ADDIU[GP.W] */
     { pool                , P_GP_D              , 2   , 32,
        0xfc000003, 0x40000001, 0                      , 0,
        0x0                 },        /* P.GP.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc000003, 0x40000002, &NMD::LW_GP_           , 0,
+       0xfc000003, 0x40000002, &LW_GP_           , 0,
        0x0                 },        /* LW[GP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc000003, 0x40000003, &NMD::SW_GP_           , 0,
+       0xfc000003, 0x40000003, &SW_GP_           , 0,
        0x0                 },        /* SW[GP] */
 };
 
 
 NMD::Pool NMD::POOL48I[32] = {
     { instruction         , 0                   , 0   , 48,
-       0xfc1f00000000ull, 0x600000000000ull, &NMD::LI_48_           , 0,
+       0xfc1f00000000ull, 0x600000000000ull, &LI_48_           , 0,
        XMMS_               },        /* LI[48] */
     { instruction         , 0                   , 0   , 48,
-       0xfc1f00000000ull, 0x600100000000ull, &NMD::ADDIU_48_        , 0,
+       0xfc1f00000000ull, 0x600100000000ull, &ADDIU_48_        , 0,
        XMMS_               },        /* ADDIU[48] */
     { instruction         , 0                   , 0   , 48,
-       0xfc1f00000000ull, 0x600200000000ull, &NMD::ADDIU_GP48_      , 0,
+       0xfc1f00000000ull, 0x600200000000ull, &ADDIU_GP48_      , 0,
        XMMS_               },        /* ADDIU[GP48] */
     { instruction         , 0                   , 0   , 48,
-       0xfc1f00000000ull, 0x600300000000ull, &NMD::ADDIUPC_48_      , 0,
+       0xfc1f00000000ull, 0x600300000000ull, &ADDIUPC_48_      , 0,
        XMMS_               },        /* ADDIUPC[48] */
     { reserved_block      , 0                   , 0   , 48,
        0xfc1f00000000ull, 0x600400000000ull, 0                      , 0,
@@ -19044,7 +19044,7 @@ NMD::Pool NMD::POOL48I[32] = {
        0xfc1f00000000ull, 0x600a00000000ull, 0                      , 0,
        0x0                 },        /* POOL48I~*(10) */
     { instruction         , 0                   , 0   , 48,
-       0xfc1f00000000ull, 0x600b00000000ull, &NMD::LWPC_48_         , 0,
+       0xfc1f00000000ull, 0x600b00000000ull, &LWPC_48_         , 0,
        XMMS_               },        /* LWPC[48] */
     { reserved_block      , 0                   , 0   , 48,
        0xfc1f00000000ull, 0x600c00000000ull, 0                      , 0,
@@ -19056,13 +19056,13 @@ NMD::Pool NMD::POOL48I[32] = {
        0xfc1f00000000ull, 0x600e00000000ull, 0                      , 0,
        0x0                 },        /* POOL48I~*(14) */
     { instruction         , 0                   , 0   , 48,
-       0xfc1f00000000ull, 0x600f00000000ull, &NMD::SWPC_48_         , 0,
+       0xfc1f00000000ull, 0x600f00000000ull, &SWPC_48_         , 0,
        XMMS_               },        /* SWPC[48] */
     { reserved_block      , 0                   , 0   , 48,
        0xfc1f00000000ull, 0x601000000000ull, 0                      , 0,
        0x0                 },        /* POOL48I~*(16) */
     { instruction         , 0                   , 0   , 48,
-       0xfc1f00000000ull, 0x601100000000ull, &NMD::DADDIU_48_       , 0,
+       0xfc1f00000000ull, 0x601100000000ull, &DADDIU_48_       , 0,
        MIPS64_             },        /* DADDIU[48] */
     { reserved_block      , 0                   , 0   , 48,
        0xfc1f00000000ull, 0x601200000000ull, 0                      , 0,
@@ -19071,7 +19071,7 @@ NMD::Pool NMD::POOL48I[32] = {
        0xfc1f00000000ull, 0x601300000000ull, 0                      , 0,
        0x0                 },        /* POOL48I~*(19) */
     { instruction         , 0                   , 0   , 48,
-       0xfc1f00000000ull, 0x601400000000ull, &NMD::DLUI_48_         , 0,
+       0xfc1f00000000ull, 0x601400000000ull, &DLUI_48_         , 0,
        MIPS64_             },        /* DLUI[48] */
     { reserved_block      , 0                   , 0   , 48,
        0xfc1f00000000ull, 0x601500000000ull, 0                      , 0,
@@ -19092,7 +19092,7 @@ NMD::Pool NMD::POOL48I[32] = {
        0xfc1f00000000ull, 0x601a00000000ull, 0                      , 0,
        0x0                 },        /* POOL48I~*(26) */
     { instruction         , 0                   , 0   , 48,
-       0xfc1f00000000ull, 0x601b00000000ull, &NMD::LDPC_48_         , 0,
+       0xfc1f00000000ull, 0x601b00000000ull, &LDPC_48_         , 0,
        MIPS64_             },        /* LDPC[48] */
     { reserved_block      , 0                   , 0   , 48,
        0xfc1f00000000ull, 0x601c00000000ull, 0                      , 0,
@@ -19104,33 +19104,33 @@ NMD::Pool NMD::POOL48I[32] = {
        0xfc1f00000000ull, 0x601e00000000ull, 0                      , 0,
        0x0                 },        /* POOL48I~*(30) */
     { instruction         , 0                   , 0   , 48,
-       0xfc1f00000000ull, 0x601f00000000ull, &NMD::SDPC_48_         , 0,
+       0xfc1f00000000ull, 0x601f00000000ull, &SDPC_48_         , 0,
        MIPS64_             },        /* SDPC[48] */
 };
 
 
 NMD::Pool NMD::PP_SR[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc10f003, 0x80003000, &NMD::SAVE_32_         , 0,
+       0xfc10f003, 0x80003000, &SAVE_32_         , 0,
        0x0                 },        /* SAVE[32] */
     { reserved_block      , 0                   , 0   , 32,
        0xfc10f003, 0x80003001, 0                      , 0,
        0x0                 },        /* PP.SR~*(1) */
     { instruction         , 0                   , 0   , 32,
-       0xfc10f003, 0x80003002, &NMD::RESTORE_32_      , 0,
+       0xfc10f003, 0x80003002, &RESTORE_32_      , 0,
        0x0                 },        /* RESTORE[32] */
     { return_instruction  , 0                   , 0   , 32,
-       0xfc10f003, 0x80003003, &NMD::RESTORE_JRC_32_  , 0,
+       0xfc10f003, 0x80003003, &RESTORE_JRC_32_  , 0,
        0x0                 },        /* RESTORE.JRC[32] */
 };
 
 
 NMD::Pool NMD::P_SR_F[8] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc10f007, 0x80103000, &NMD::SAVEF            , 0,
+       0xfc10f007, 0x80103000, &SAVEF            , 0,
        CP1_                },        /* SAVEF */
     { instruction         , 0                   , 0   , 32,
-       0xfc10f007, 0x80103001, &NMD::RESTOREF         , 0,
+       0xfc10f007, 0x80103001, &RESTOREF         , 0,
        CP1_                },        /* RESTOREF */
     { reserved_block      , 0                   , 0   , 32,
        0xfc10f007, 0x80103002, 0                      , 0,
@@ -19165,19 +19165,19 @@ NMD::Pool NMD::P_SR[2] = {
 
 NMD::Pool NMD::P_SLL[5] = {
     { instruction         , 0                   , 0   , 32,
-       0xffe0f1ff, 0x8000c000, &NMD::NOP_32_          , 0,
+       0xffe0f1ff, 0x8000c000, &NOP_32_          , 0,
        0x0                 },        /* NOP[32] */
     { instruction         , 0                   , 0   , 32,
-       0xffe0f1ff, 0x8000c003, &NMD::EHB              , 0,
+       0xffe0f1ff, 0x8000c003, &EHB              , 0,
        0x0                 },        /* EHB */
     { instruction         , 0                   , 0   , 32,
-       0xffe0f1ff, 0x8000c005, &NMD::PAUSE            , 0,
+       0xffe0f1ff, 0x8000c005, &PAUSE            , 0,
        0x0                 },        /* PAUSE */
     { instruction         , 0                   , 0   , 32,
-       0xffe0f1ff, 0x8000c006, &NMD::SYNC             , 0,
+       0xffe0f1ff, 0x8000c006, &SYNC             , 0,
        0x0                 },        /* SYNC */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c000, &NMD::SLL_32_          , 0,
+       0xfc00f1e0, 0x8000c000, &SLL_32_          , 0,
        0x0                 },        /* SLL[32] */
 };
 
@@ -19190,53 +19190,53 @@ NMD::Pool NMD::P_SHIFT[16] = {
        0xfc00f1e0, 0x8000c020, 0                      , 0,
        0x0                 },        /* P.SHIFT~*(1) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c040, &NMD::SRL_32_          , 0,
+       0xfc00f1e0, 0x8000c040, &SRL_32_          , 0,
        0x0                 },        /* SRL[32] */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00f1e0, 0x8000c060, 0                      , 0,
        0x0                 },        /* P.SHIFT~*(3) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c080, &NMD::SRA              , 0,
+       0xfc00f1e0, 0x8000c080, &SRA              , 0,
        0x0                 },        /* SRA */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00f1e0, 0x8000c0a0, 0                      , 0,
        0x0                 },        /* P.SHIFT~*(5) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c0c0, &NMD::ROTR             , 0,
+       0xfc00f1e0, 0x8000c0c0, &ROTR             , 0,
        0x0                 },        /* ROTR */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00f1e0, 0x8000c0e0, 0                      , 0,
        0x0                 },        /* P.SHIFT~*(7) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c100, &NMD::DSLL             , 0,
+       0xfc00f1e0, 0x8000c100, &DSLL             , 0,
        MIPS64_             },        /* DSLL */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c120, &NMD::DSLL32           , 0,
+       0xfc00f1e0, 0x8000c120, &DSLL32           , 0,
        MIPS64_             },        /* DSLL32 */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c140, &NMD::DSRL             , 0,
+       0xfc00f1e0, 0x8000c140, &DSRL             , 0,
        MIPS64_             },        /* DSRL */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c160, &NMD::DSRL32           , 0,
+       0xfc00f1e0, 0x8000c160, &DSRL32           , 0,
        MIPS64_             },        /* DSRL32 */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c180, &NMD::DSRA             , 0,
+       0xfc00f1e0, 0x8000c180, &DSRA             , 0,
        MIPS64_             },        /* DSRA */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c1a0, &NMD::DSRA32           , 0,
+       0xfc00f1e0, 0x8000c1a0, &DSRA32           , 0,
        MIPS64_             },        /* DSRA32 */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c1c0, &NMD::DROTR            , 0,
+       0xfc00f1e0, 0x8000c1c0, &DROTR            , 0,
        MIPS64_             },        /* DROTR */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f1e0, 0x8000c1e0, &NMD::DROTR32          , 0,
+       0xfc00f1e0, 0x8000c1e0, &DROTR32          , 0,
        MIPS64_             },        /* DROTR32 */
 };
 
 
 NMD::Pool NMD::P_ROTX[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00f820, 0x8000d000, &NMD::ROTX             , 0,
+       0xfc00f820, 0x8000d000, &ROTX             , 0,
        XMMS_               },        /* ROTX */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00f820, 0x8000d020, 0                      , 0,
@@ -19252,72 +19252,72 @@ NMD::Pool NMD::P_ROTX[4] = {
 
 NMD::Pool NMD::P_INS[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00f820, 0x8000e000, &NMD::INS              , 0,
+       0xfc00f820, 0x8000e000, &INS              , 0,
        XMMS_               },        /* INS */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f820, 0x8000e020, &NMD::DINSU            , 0,
+       0xfc00f820, 0x8000e020, &DINSU            , 0,
        MIPS64_             },        /* DINSU */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f820, 0x8000e800, &NMD::DINSM            , 0,
+       0xfc00f820, 0x8000e800, &DINSM            , 0,
        MIPS64_             },        /* DINSM */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f820, 0x8000e820, &NMD::DINS             , 0,
+       0xfc00f820, 0x8000e820, &DINS             , 0,
        MIPS64_             },        /* DINS */
 };
 
 
 NMD::Pool NMD::P_EXT[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00f820, 0x8000f000, &NMD::EXT              , 0,
+       0xfc00f820, 0x8000f000, &EXT              , 0,
        XMMS_               },        /* EXT */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f820, 0x8000f020, &NMD::DEXTU            , 0,
+       0xfc00f820, 0x8000f020, &DEXTU            , 0,
        MIPS64_             },        /* DEXTU */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f820, 0x8000f800, &NMD::DEXTM            , 0,
+       0xfc00f820, 0x8000f800, &DEXTM            , 0,
        MIPS64_             },        /* DEXTM */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f820, 0x8000f820, &NMD::DEXT             , 0,
+       0xfc00f820, 0x8000f820, &DEXT             , 0,
        MIPS64_             },        /* DEXT */
 };
 
 
 NMD::Pool NMD::P_U12[16] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x80000000, &NMD::ORI              , 0,
+       0xfc00f000, 0x80000000, &ORI              , 0,
        0x0                 },        /* ORI */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x80001000, &NMD::XORI             , 0,
+       0xfc00f000, 0x80001000, &XORI             , 0,
        0x0                 },        /* XORI */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x80002000, &NMD::ANDI_32_         , 0,
+       0xfc00f000, 0x80002000, &ANDI_32_         , 0,
        0x0                 },        /* ANDI[32] */
     { pool                , P_SR                , 2   , 32,
        0xfc00f000, 0x80003000, 0                      , 0,
        0x0                 },        /* P.SR */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x80004000, &NMD::SLTI             , 0,
+       0xfc00f000, 0x80004000, &SLTI             , 0,
        0x0                 },        /* SLTI */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x80005000, &NMD::SLTIU            , 0,
+       0xfc00f000, 0x80005000, &SLTIU            , 0,
        0x0                 },        /* SLTIU */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x80006000, &NMD::SEQI             , 0,
+       0xfc00f000, 0x80006000, &SEQI             , 0,
        0x0                 },        /* SEQI */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00f000, 0x80007000, 0                      , 0,
        0x0                 },        /* P.U12~*(7) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x80008000, &NMD::ADDIU_NEG_       , 0,
+       0xfc00f000, 0x80008000, &ADDIU_NEG_       , 0,
        0x0                 },        /* ADDIU[NEG] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x80009000, &NMD::DADDIU_U12_      , 0,
+       0xfc00f000, 0x80009000, &DADDIU_U12_      , 0,
        MIPS64_             },        /* DADDIU[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x8000a000, &NMD::DADDIU_NEG_      , 0,
+       0xfc00f000, 0x8000a000, &DADDIU_NEG_      , 0,
        MIPS64_             },        /* DADDIU[NEG] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x8000b000, &NMD::DROTX            , 0,
+       0xfc00f000, 0x8000b000, &DROTX            , 0,
        MIPS64_             },        /* DROTX */
     { pool                , P_SHIFT             , 16  , 32,
        0xfc00f000, 0x8000c000, 0                      , 0,
@@ -19336,17 +19336,17 @@ NMD::Pool NMD::P_U12[16] = {
 
 NMD::Pool NMD::RINT_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000020, &NMD::RINT_S           , 0,
+       0xfc0003ff, 0xa0000020, &RINT_S           , 0,
        CP1_                },        /* RINT.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000220, &NMD::RINT_D           , 0,
+       0xfc0003ff, 0xa0000220, &RINT_D           , 0,
        CP1_                },        /* RINT.D */
 };
 
 
 NMD::Pool NMD::ADD_fmt0[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000030, &NMD::ADD_S            , 0,
+       0xfc0003ff, 0xa0000030, &ADD_S            , 0,
        CP1_                },        /* ADD.S */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000230, 0                      , 0,
@@ -19356,27 +19356,27 @@ NMD::Pool NMD::ADD_fmt0[2] = {
 
 NMD::Pool NMD::SELEQZ_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000038, &NMD::SELEQZ_S         , 0,
+       0xfc0003ff, 0xa0000038, &SELEQZ_S         , 0,
        CP1_                },        /* SELEQZ.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000238, &NMD::SELEQZ_D         , 0,
+       0xfc0003ff, 0xa0000238, &SELEQZ_D         , 0,
        CP1_                },        /* SELEQZ.D */
 };
 
 
 NMD::Pool NMD::CLASS_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000060, &NMD::CLASS_S          , 0,
+       0xfc0003ff, 0xa0000060, &CLASS_S          , 0,
        CP1_                },        /* CLASS.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000260, &NMD::CLASS_D          , 0,
+       0xfc0003ff, 0xa0000260, &CLASS_D          , 0,
        CP1_                },        /* CLASS.D */
 };
 
 
 NMD::Pool NMD::SUB_fmt0[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000070, &NMD::SUB_S            , 0,
+       0xfc0003ff, 0xa0000070, &SUB_S            , 0,
        CP1_                },        /* SUB.S */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000270, 0                      , 0,
@@ -19386,17 +19386,17 @@ NMD::Pool NMD::SUB_fmt0[2] = {
 
 NMD::Pool NMD::SELNEZ_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000078, &NMD::SELNEZ_S         , 0,
+       0xfc0003ff, 0xa0000078, &SELNEZ_S         , 0,
        CP1_                },        /* SELNEZ.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000278, &NMD::SELNEZ_D         , 0,
+       0xfc0003ff, 0xa0000278, &SELNEZ_D         , 0,
        CP1_                },        /* SELNEZ.D */
 };
 
 
 NMD::Pool NMD::MUL_fmt0[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa00000b0, &NMD::MUL_S            , 0,
+       0xfc0003ff, 0xa00000b0, &MUL_S            , 0,
        CP1_                },        /* MUL.S */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0xa00002b0, 0                      , 0,
@@ -19406,17 +19406,17 @@ NMD::Pool NMD::MUL_fmt0[2] = {
 
 NMD::Pool NMD::SEL_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa00000b8, &NMD::SEL_S            , 0,
+       0xfc0003ff, 0xa00000b8, &SEL_S            , 0,
        CP1_                },        /* SEL.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa00002b8, &NMD::SEL_D            , 0,
+       0xfc0003ff, 0xa00002b8, &SEL_D            , 0,
        CP1_                },        /* SEL.D */
 };
 
 
 NMD::Pool NMD::DIV_fmt0[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa00000f0, &NMD::DIV_S            , 0,
+       0xfc0003ff, 0xa00000f0, &DIV_S            , 0,
        CP1_                },        /* DIV.S */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0xa00002f0, 0                      , 0,
@@ -19426,7 +19426,7 @@ NMD::Pool NMD::DIV_fmt0[2] = {
 
 NMD::Pool NMD::ADD_fmt1[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000130, &NMD::ADD_D            , 0,
+       0xfc0003ff, 0xa0000130, &ADD_D            , 0,
        CP1_                },        /* ADD.D */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000330, 0                      , 0,
@@ -19436,7 +19436,7 @@ NMD::Pool NMD::ADD_fmt1[2] = {
 
 NMD::Pool NMD::SUB_fmt1[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa0000170, &NMD::SUB_D            , 0,
+       0xfc0003ff, 0xa0000170, &SUB_D            , 0,
        CP1_                },        /* SUB.D */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000370, 0                      , 0,
@@ -19446,7 +19446,7 @@ NMD::Pool NMD::SUB_fmt1[2] = {
 
 NMD::Pool NMD::MUL_fmt1[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa00001b0, &NMD::MUL_D            , 0,
+       0xfc0003ff, 0xa00001b0, &MUL_D            , 0,
        CP1_                },        /* MUL.D */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0xa00003b0, 0                      , 0,
@@ -19456,17 +19456,17 @@ NMD::Pool NMD::MUL_fmt1[2] = {
 
 NMD::Pool NMD::MADDF_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa00001b8, &NMD::MADDF_S          , 0,
+       0xfc0003ff, 0xa00001b8, &MADDF_S          , 0,
        CP1_                },        /* MADDF.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa00003b8, &NMD::MADDF_D          , 0,
+       0xfc0003ff, 0xa00003b8, &MADDF_D          , 0,
        CP1_                },        /* MADDF.D */
 };
 
 
 NMD::Pool NMD::DIV_fmt1[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa00001f0, &NMD::DIV_D            , 0,
+       0xfc0003ff, 0xa00001f0, &DIV_D            , 0,
        CP1_                },        /* DIV.D */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0003ff, 0xa00003f0, 0                      , 0,
@@ -19476,10 +19476,10 @@ NMD::Pool NMD::DIV_fmt1[2] = {
 
 NMD::Pool NMD::MSUBF_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa00001f8, &NMD::MSUBF_S          , 0,
+       0xfc0003ff, 0xa00001f8, &MSUBF_S          , 0,
        CP1_                },        /* MSUBF.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0003ff, 0xa00003f8, &NMD::MSUBF_D          , 0,
+       0xfc0003ff, 0xa00003f8, &MSUBF_D          , 0,
        CP1_                },        /* MSUBF.D */
 };
 
@@ -19682,170 +19682,170 @@ NMD::Pool NMD::POOL32F_0[64] = {
 
 NMD::Pool NMD::MIN_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00023f, 0xa0000003, &NMD::MIN_S            , 0,
+       0xfc00023f, 0xa0000003, &MIN_S            , 0,
        CP1_                },        /* MIN.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc00023f, 0xa0000203, &NMD::MIN_D            , 0,
+       0xfc00023f, 0xa0000203, &MIN_D            , 0,
        CP1_                },        /* MIN.D */
 };
 
 
 NMD::Pool NMD::MAX_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00023f, 0xa000000b, &NMD::MAX_S            , 0,
+       0xfc00023f, 0xa000000b, &MAX_S            , 0,
        CP1_                },        /* MAX.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc00023f, 0xa000020b, &NMD::MAX_D            , 0,
+       0xfc00023f, 0xa000020b, &MAX_D            , 0,
        CP1_                },        /* MAX.D */
 };
 
 
 NMD::Pool NMD::MINA_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00023f, 0xa0000023, &NMD::MINA_S           , 0,
+       0xfc00023f, 0xa0000023, &MINA_S           , 0,
        CP1_                },        /* MINA.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc00023f, 0xa0000223, &NMD::MINA_D           , 0,
+       0xfc00023f, 0xa0000223, &MINA_D           , 0,
        CP1_                },        /* MINA.D */
 };
 
 
 NMD::Pool NMD::MAXA_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00023f, 0xa000002b, &NMD::MAXA_S           , 0,
+       0xfc00023f, 0xa000002b, &MAXA_S           , 0,
        CP1_                },        /* MAXA.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc00023f, 0xa000022b, &NMD::MAXA_D           , 0,
+       0xfc00023f, 0xa000022b, &MAXA_D           , 0,
        CP1_                },        /* MAXA.D */
 };
 
 
 NMD::Pool NMD::CVT_L_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000013b, &NMD::CVT_L_S          , 0,
+       0xfc007fff, 0xa000013b, &CVT_L_S          , 0,
        CP1_                },        /* CVT.L.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000413b, &NMD::CVT_L_D          , 0,
+       0xfc007fff, 0xa000413b, &CVT_L_D          , 0,
        CP1_                },        /* CVT.L.D */
 };
 
 
 NMD::Pool NMD::RSQRT_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000023b, &NMD::RSQRT_S          , 0,
+       0xfc007fff, 0xa000023b, &RSQRT_S          , 0,
        CP1_                },        /* RSQRT.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000423b, &NMD::RSQRT_D          , 0,
+       0xfc007fff, 0xa000423b, &RSQRT_D          , 0,
        CP1_                },        /* RSQRT.D */
 };
 
 
 NMD::Pool NMD::FLOOR_L_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000033b, &NMD::FLOOR_L_S        , 0,
+       0xfc007fff, 0xa000033b, &FLOOR_L_S        , 0,
        CP1_                },        /* FLOOR.L.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000433b, &NMD::FLOOR_L_D        , 0,
+       0xfc007fff, 0xa000433b, &FLOOR_L_D        , 0,
        CP1_                },        /* FLOOR.L.D */
 };
 
 
 NMD::Pool NMD::CVT_W_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000093b, &NMD::CVT_W_S          , 0,
+       0xfc007fff, 0xa000093b, &CVT_W_S          , 0,
        CP1_                },        /* CVT.W.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000493b, &NMD::CVT_W_D          , 0,
+       0xfc007fff, 0xa000493b, &CVT_W_D          , 0,
        CP1_                },        /* CVT.W.D */
 };
 
 
 NMD::Pool NMD::SQRT_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0000a3b, &NMD::SQRT_S           , 0,
+       0xfc007fff, 0xa0000a3b, &SQRT_S           , 0,
        CP1_                },        /* SQRT.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0004a3b, &NMD::SQRT_D           , 0,
+       0xfc007fff, 0xa0004a3b, &SQRT_D           , 0,
        CP1_                },        /* SQRT.D */
 };
 
 
 NMD::Pool NMD::FLOOR_W_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0000b3b, &NMD::FLOOR_W_S        , 0,
+       0xfc007fff, 0xa0000b3b, &FLOOR_W_S        , 0,
        CP1_                },        /* FLOOR.W.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0004b3b, &NMD::FLOOR_W_D        , 0,
+       0xfc007fff, 0xa0004b3b, &FLOOR_W_D        , 0,
        CP1_                },        /* FLOOR.W.D */
 };
 
 
 NMD::Pool NMD::RECIP_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000123b, &NMD::RECIP_S          , 0,
+       0xfc007fff, 0xa000123b, &RECIP_S          , 0,
        CP1_                },        /* RECIP.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000523b, &NMD::RECIP_D          , 0,
+       0xfc007fff, 0xa000523b, &RECIP_D          , 0,
        CP1_                },        /* RECIP.D */
 };
 
 
 NMD::Pool NMD::CEIL_L_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000133b, &NMD::CEIL_L_S         , 0,
+       0xfc007fff, 0xa000133b, &CEIL_L_S         , 0,
        CP1_                },        /* CEIL.L.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000533b, &NMD::CEIL_L_D         , 0,
+       0xfc007fff, 0xa000533b, &CEIL_L_D         , 0,
        CP1_                },        /* CEIL.L.D */
 };
 
 
 NMD::Pool NMD::CEIL_W_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0001b3b, &NMD::CEIL_W_S         , 0,
+       0xfc007fff, 0xa0001b3b, &CEIL_W_S         , 0,
        CP1_                },        /* CEIL.W.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0005b3b, &NMD::CEIL_W_D         , 0,
+       0xfc007fff, 0xa0005b3b, &CEIL_W_D         , 0,
        CP1_                },        /* CEIL.W.D */
 };
 
 
 NMD::Pool NMD::TRUNC_L_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000233b, &NMD::TRUNC_L_S        , 0,
+       0xfc007fff, 0xa000233b, &TRUNC_L_S        , 0,
        CP1_                },        /* TRUNC.L.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000633b, &NMD::TRUNC_L_D        , 0,
+       0xfc007fff, 0xa000633b, &TRUNC_L_D        , 0,
        CP1_                },        /* TRUNC.L.D */
 };
 
 
 NMD::Pool NMD::TRUNC_W_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0002b3b, &NMD::TRUNC_W_S        , 0,
+       0xfc007fff, 0xa0002b3b, &TRUNC_W_S        , 0,
        CP1_                },        /* TRUNC.W.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0006b3b, &NMD::TRUNC_W_D        , 0,
+       0xfc007fff, 0xa0006b3b, &TRUNC_W_D        , 0,
        CP1_                },        /* TRUNC.W.D */
 };
 
 
 NMD::Pool NMD::ROUND_L_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000333b, &NMD::ROUND_L_S        , 0,
+       0xfc007fff, 0xa000333b, &ROUND_L_S        , 0,
        CP1_                },        /* ROUND.L.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000733b, &NMD::ROUND_L_D        , 0,
+       0xfc007fff, 0xa000733b, &ROUND_L_D        , 0,
        CP1_                },        /* ROUND.L.D */
 };
 
 
 NMD::Pool NMD::ROUND_W_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0003b3b, &NMD::ROUND_W_S        , 0,
+       0xfc007fff, 0xa0003b3b, &ROUND_W_S        , 0,
        CP1_                },        /* ROUND.W.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0007b3b, &NMD::ROUND_W_D        , 0,
+       0xfc007fff, 0xa0007b3b, &ROUND_W_D        , 0,
        CP1_                },        /* ROUND.W.D */
 };
 
@@ -19900,7 +19900,7 @@ NMD::Pool NMD::POOL32Fxf_0[64] = {
        0xfc003fff, 0xa0000f3b, 0                      , 0,
        CP1_                },        /* POOL32Fxf_0~*(15) */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0xa000103b, &NMD::CFC1             , 0,
+       0xfc003fff, 0xa000103b, &CFC1             , 0,
        CP1_                },        /* CFC1 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0xa000113b, 0                      , 0,
@@ -19924,7 +19924,7 @@ NMD::Pool NMD::POOL32Fxf_0[64] = {
        0xfc003fff, 0xa000173b, 0                      , 0,
        CP1_                },        /* POOL32Fxf_0~*(23) */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0xa000183b, &NMD::CTC1             , 0,
+       0xfc003fff, 0xa000183b, &CTC1             , 0,
        CP1_                },        /* CTC1 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0xa000193b, 0                      , 0,
@@ -19948,10 +19948,10 @@ NMD::Pool NMD::POOL32Fxf_0[64] = {
        0xfc003fff, 0xa0001f3b, 0                      , 0,
        CP1_                },        /* POOL32Fxf_0~*(31) */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0xa000203b, &NMD::MFC1             , 0,
+       0xfc003fff, 0xa000203b, &MFC1             , 0,
        CP1_                },        /* MFC1 */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0xa000213b, &NMD::CVT_S_PL         , 0,
+       0xfc003fff, 0xa000213b, &CVT_S_PL         , 0,
        CP1_                },        /* CVT.S.PL */
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0xa000223b, 0                      , 0,
@@ -19960,7 +19960,7 @@ NMD::Pool NMD::POOL32Fxf_0[64] = {
        0xfc003fff, 0xa000233b, 0                      , 0,
        CP1_                },        /* TRUNC.L.fmt */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0xa000243b, &NMD::DMFC1            , 0,
+       0xfc003fff, 0xa000243b, &DMFC1            , 0,
        CP1_ | MIPS64_      },        /* DMFC1 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0xa000253b, 0                      , 0,
@@ -19972,10 +19972,10 @@ NMD::Pool NMD::POOL32Fxf_0[64] = {
        0xfc003fff, 0xa000273b, 0                      , 0,
        CP1_                },        /* POOL32Fxf_0~*(39) */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0xa000283b, &NMD::MTC1             , 0,
+       0xfc003fff, 0xa000283b, &MTC1             , 0,
        CP1_                },        /* MTC1 */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0xa000293b, &NMD::CVT_S_PU         , 0,
+       0xfc003fff, 0xa000293b, &CVT_S_PU         , 0,
        CP1_                },        /* CVT.S.PU */
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0xa0002a3b, 0                      , 0,
@@ -19984,7 +19984,7 @@ NMD::Pool NMD::POOL32Fxf_0[64] = {
        0xfc003fff, 0xa0002b3b, 0                      , 0,
        CP1_                },        /* TRUNC.W.fmt */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0xa0002c3b, &NMD::DMTC1            , 0,
+       0xfc003fff, 0xa0002c3b, &DMTC1            , 0,
        CP1_ | MIPS64_      },        /* DMTC1 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0xa0002d3b, 0                      , 0,
@@ -19996,7 +19996,7 @@ NMD::Pool NMD::POOL32Fxf_0[64] = {
        0xfc003fff, 0xa0002f3b, 0                      , 0,
        CP1_                },        /* POOL32Fxf_0~*(47) */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0xa000303b, &NMD::MFHC1            , 0,
+       0xfc003fff, 0xa000303b, &MFHC1            , 0,
        CP1_                },        /* MFHC1 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0xa000313b, 0                      , 0,
@@ -20020,7 +20020,7 @@ NMD::Pool NMD::POOL32Fxf_0[64] = {
        0xfc003fff, 0xa000373b, 0                      , 0,
        CP1_                },        /* POOL32Fxf_0~*(55) */
     { instruction         , 0                   , 0   , 32,
-       0xfc003fff, 0xa000383b, &NMD::MTHC1            , 0,
+       0xfc003fff, 0xa000383b, &MTHC1            , 0,
        CP1_                },        /* MTHC1 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0xa000393b, 0                      , 0,
@@ -20048,10 +20048,10 @@ NMD::Pool NMD::POOL32Fxf_0[64] = {
 
 NMD::Pool NMD::MOV_fmt[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000007b, &NMD::MOV_S            , 0,
+       0xfc007fff, 0xa000007b, &MOV_S            , 0,
        CP1_                },        /* MOV.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000207b, &NMD::MOV_D            , 0,
+       0xfc007fff, 0xa000207b, &MOV_D            , 0,
        CP1_                },        /* MOV.D */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007fff, 0xa000407b, 0                      , 0,
@@ -20064,10 +20064,10 @@ NMD::Pool NMD::MOV_fmt[4] = {
 
 NMD::Pool NMD::ABS_fmt[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000037b, &NMD::ABS_S            , 0,
+       0xfc007fff, 0xa000037b, &ABS_S            , 0,
        CP1_                },        /* ABS.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000237b, &NMD::ABS_D            , 0,
+       0xfc007fff, 0xa000237b, &ABS_D            , 0,
        CP1_                },        /* ABS.D */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007fff, 0xa000437b, 0                      , 0,
@@ -20080,10 +20080,10 @@ NMD::Pool NMD::ABS_fmt[4] = {
 
 NMD::Pool NMD::NEG_fmt[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0000b7b, &NMD::NEG_S            , 0,
+       0xfc007fff, 0xa0000b7b, &NEG_S            , 0,
        CP1_                },        /* NEG.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0002b7b, &NMD::NEG_D            , 0,
+       0xfc007fff, 0xa0002b7b, &NEG_D            , 0,
        CP1_                },        /* NEG.D */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007fff, 0xa0004b7b, 0                      , 0,
@@ -20096,13 +20096,13 @@ NMD::Pool NMD::NEG_fmt[4] = {
 
 NMD::Pool NMD::CVT_D_fmt[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000137b, &NMD::CVT_D_S          , 0,
+       0xfc007fff, 0xa000137b, &CVT_D_S          , 0,
        CP1_                },        /* CVT.D.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000337b, &NMD::CVT_D_W          , 0,
+       0xfc007fff, 0xa000337b, &CVT_D_W          , 0,
        CP1_                },        /* CVT.D.W */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa000537b, &NMD::CVT_D_L          , 0,
+       0xfc007fff, 0xa000537b, &CVT_D_L          , 0,
        CP1_                },        /* CVT.D.L */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007fff, 0xa000737b, 0                      , 0,
@@ -20112,13 +20112,13 @@ NMD::Pool NMD::CVT_D_fmt[4] = {
 
 NMD::Pool NMD::CVT_S_fmt[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0001b7b, &NMD::CVT_S_D          , 0,
+       0xfc007fff, 0xa0001b7b, &CVT_S_D          , 0,
        CP1_                },        /* CVT.S.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0003b7b, &NMD::CVT_S_W          , 0,
+       0xfc007fff, 0xa0003b7b, &CVT_S_W          , 0,
        CP1_                },        /* CVT.S.W */
     { instruction         , 0                   , 0   , 32,
-       0xfc007fff, 0xa0005b7b, &NMD::CVT_S_L          , 0,
+       0xfc007fff, 0xa0005b7b, &CVT_S_L          , 0,
        CP1_                },        /* CVT.S.L */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007fff, 0xa0007b7b, 0                      , 0,
@@ -20272,64 +20272,64 @@ NMD::Pool NMD::POOL32F_3[8] = {
 
 NMD::Pool NMD::CMP_condn_S[32] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000005, &NMD::CMP_AF_S         , 0,
+       0xfc0007ff, 0xa0000005, &CMP_AF_S         , 0,
        CP1_                },        /* CMP.AF.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000045, &NMD::CMP_UN_S         , 0,
+       0xfc0007ff, 0xa0000045, &CMP_UN_S         , 0,
        CP1_                },        /* CMP.UN.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000085, &NMD::CMP_EQ_S         , 0,
+       0xfc0007ff, 0xa0000085, &CMP_EQ_S         , 0,
        CP1_                },        /* CMP.EQ.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00000c5, &NMD::CMP_UEQ_S        , 0,
+       0xfc0007ff, 0xa00000c5, &CMP_UEQ_S        , 0,
        CP1_                },        /* CMP.UEQ.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000105, &NMD::CMP_LT_S         , 0,
+       0xfc0007ff, 0xa0000105, &CMP_LT_S         , 0,
        CP1_                },        /* CMP.LT.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000145, &NMD::CMP_ULT_S        , 0,
+       0xfc0007ff, 0xa0000145, &CMP_ULT_S        , 0,
        CP1_                },        /* CMP.ULT.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000185, &NMD::CMP_LE_S         , 0,
+       0xfc0007ff, 0xa0000185, &CMP_LE_S         , 0,
        CP1_                },        /* CMP.LE.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00001c5, &NMD::CMP_ULE_S        , 0,
+       0xfc0007ff, 0xa00001c5, &CMP_ULE_S        , 0,
        CP1_                },        /* CMP.ULE.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000205, &NMD::CMP_SAF_S        , 0,
+       0xfc0007ff, 0xa0000205, &CMP_SAF_S        , 0,
        CP1_                },        /* CMP.SAF.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000245, &NMD::CMP_SUN_S        , 0,
+       0xfc0007ff, 0xa0000245, &CMP_SUN_S        , 0,
        CP1_                },        /* CMP.SUN.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000285, &NMD::CMP_SEQ_S        , 0,
+       0xfc0007ff, 0xa0000285, &CMP_SEQ_S        , 0,
        CP1_                },        /* CMP.SEQ.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00002c5, &NMD::CMP_SUEQ_S       , 0,
+       0xfc0007ff, 0xa00002c5, &CMP_SUEQ_S       , 0,
        CP1_                },        /* CMP.SUEQ.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000305, &NMD::CMP_SLT_S        , 0,
+       0xfc0007ff, 0xa0000305, &CMP_SLT_S        , 0,
        CP1_                },        /* CMP.SLT.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000345, &NMD::CMP_SULT_S       , 0,
+       0xfc0007ff, 0xa0000345, &CMP_SULT_S       , 0,
        CP1_                },        /* CMP.SULT.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000385, &NMD::CMP_SLE_S        , 0,
+       0xfc0007ff, 0xa0000385, &CMP_SLE_S        , 0,
        CP1_                },        /* CMP.SLE.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00003c5, &NMD::CMP_SULE_S       , 0,
+       0xfc0007ff, 0xa00003c5, &CMP_SULE_S       , 0,
        CP1_                },        /* CMP.SULE.S */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0007ff, 0xa0000405, 0                      , 0,
        CP1_                },        /* CMP.condn.S~*(16) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000445, &NMD::CMP_OR_S         , 0,
+       0xfc0007ff, 0xa0000445, &CMP_OR_S         , 0,
        CP1_                },        /* CMP.OR.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000485, &NMD::CMP_UNE_S        , 0,
+       0xfc0007ff, 0xa0000485, &CMP_UNE_S        , 0,
        CP1_                },        /* CMP.UNE.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00004c5, &NMD::CMP_NE_S         , 0,
+       0xfc0007ff, 0xa00004c5, &CMP_NE_S         , 0,
        CP1_                },        /* CMP.NE.S */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0007ff, 0xa0000505, 0                      , 0,
@@ -20347,13 +20347,13 @@ NMD::Pool NMD::CMP_condn_S[32] = {
        0xfc0007ff, 0xa0000605, 0                      , 0,
        CP1_                },        /* CMP.condn.S~*(24) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000645, &NMD::CMP_SOR_S        , 0,
+       0xfc0007ff, 0xa0000645, &CMP_SOR_S        , 0,
        CP1_                },        /* CMP.SOR.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000685, &NMD::CMP_SUNE_S       , 0,
+       0xfc0007ff, 0xa0000685, &CMP_SUNE_S       , 0,
        CP1_                },        /* CMP.SUNE.S */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00006c5, &NMD::CMP_SNE_S        , 0,
+       0xfc0007ff, 0xa00006c5, &CMP_SNE_S        , 0,
        CP1_                },        /* CMP.SNE.S */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0007ff, 0xa0000705, 0                      , 0,
@@ -20372,64 +20372,64 @@ NMD::Pool NMD::CMP_condn_S[32] = {
 
 NMD::Pool NMD::CMP_condn_D[32] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000015, &NMD::CMP_AF_D         , 0,
+       0xfc0007ff, 0xa0000015, &CMP_AF_D         , 0,
        CP1_                },        /* CMP.AF.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000055, &NMD::CMP_UN_D         , 0,
+       0xfc0007ff, 0xa0000055, &CMP_UN_D         , 0,
        CP1_                },        /* CMP.UN.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000095, &NMD::CMP_EQ_D         , 0,
+       0xfc0007ff, 0xa0000095, &CMP_EQ_D         , 0,
        CP1_                },        /* CMP.EQ.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00000d5, &NMD::CMP_UEQ_D        , 0,
+       0xfc0007ff, 0xa00000d5, &CMP_UEQ_D        , 0,
        CP1_                },        /* CMP.UEQ.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000115, &NMD::CMP_LT_D         , 0,
+       0xfc0007ff, 0xa0000115, &CMP_LT_D         , 0,
        CP1_                },        /* CMP.LT.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000155, &NMD::CMP_ULT_D        , 0,
+       0xfc0007ff, 0xa0000155, &CMP_ULT_D        , 0,
        CP1_                },        /* CMP.ULT.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000195, &NMD::CMP_LE_D         , 0,
+       0xfc0007ff, 0xa0000195, &CMP_LE_D         , 0,
        CP1_                },        /* CMP.LE.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00001d5, &NMD::CMP_ULE_D        , 0,
+       0xfc0007ff, 0xa00001d5, &CMP_ULE_D        , 0,
        CP1_                },        /* CMP.ULE.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000215, &NMD::CMP_SAF_D        , 0,
+       0xfc0007ff, 0xa0000215, &CMP_SAF_D        , 0,
        CP1_                },        /* CMP.SAF.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000255, &NMD::CMP_SUN_D        , 0,
+       0xfc0007ff, 0xa0000255, &CMP_SUN_D        , 0,
        CP1_                },        /* CMP.SUN.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000295, &NMD::CMP_SEQ_D        , 0,
+       0xfc0007ff, 0xa0000295, &CMP_SEQ_D        , 0,
        CP1_                },        /* CMP.SEQ.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00002d5, &NMD::CMP_SUEQ_D       , 0,
+       0xfc0007ff, 0xa00002d5, &CMP_SUEQ_D       , 0,
        CP1_                },        /* CMP.SUEQ.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000315, &NMD::CMP_SLT_D        , 0,
+       0xfc0007ff, 0xa0000315, &CMP_SLT_D        , 0,
        CP1_                },        /* CMP.SLT.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000355, &NMD::CMP_SULT_D       , 0,
+       0xfc0007ff, 0xa0000355, &CMP_SULT_D       , 0,
        CP1_                },        /* CMP.SULT.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000395, &NMD::CMP_SLE_D        , 0,
+       0xfc0007ff, 0xa0000395, &CMP_SLE_D        , 0,
        CP1_                },        /* CMP.SLE.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00003d5, &NMD::CMP_SULE_D       , 0,
+       0xfc0007ff, 0xa00003d5, &CMP_SULE_D       , 0,
        CP1_                },        /* CMP.SULE.D */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0007ff, 0xa0000415, 0                      , 0,
        CP1_                },        /* CMP.condn.D~*(16) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000455, &NMD::CMP_OR_D         , 0,
+       0xfc0007ff, 0xa0000455, &CMP_OR_D         , 0,
        CP1_                },        /* CMP.OR.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000495, &NMD::CMP_UNE_D        , 0,
+       0xfc0007ff, 0xa0000495, &CMP_UNE_D        , 0,
        CP1_                },        /* CMP.UNE.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00004d5, &NMD::CMP_NE_D         , 0,
+       0xfc0007ff, 0xa00004d5, &CMP_NE_D         , 0,
        CP1_                },        /* CMP.NE.D */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0007ff, 0xa0000515, 0                      , 0,
@@ -20447,13 +20447,13 @@ NMD::Pool NMD::CMP_condn_D[32] = {
        0xfc0007ff, 0xa0000615, 0                      , 0,
        CP1_                },        /* CMP.condn.D~*(24) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000655, &NMD::CMP_SOR_D        , 0,
+       0xfc0007ff, 0xa0000655, &CMP_SOR_D        , 0,
        CP1_                },        /* CMP.SOR.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa0000695, &NMD::CMP_SUNE_D       , 0,
+       0xfc0007ff, 0xa0000695, &CMP_SUNE_D       , 0,
        CP1_                },        /* CMP.SUNE.D */
     { instruction         , 0                   , 0   , 32,
-       0xfc0007ff, 0xa00006d5, &NMD::CMP_SNE_D        , 0,
+       0xfc0007ff, 0xa00006d5, &CMP_SNE_D        , 0,
        CP1_                },        /* CMP.SNE.D */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0007ff, 0xa0000715, 0                      , 0,
@@ -20531,13 +20531,13 @@ NMD::Pool NMD::POOL32S_0[64] = {
        0xfc0001ff, 0xc0000000, 0                      , 0,
        0x0                 },        /* POOL32S_0~*(0) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000008, &NMD::DLSA             , 0,
+       0xfc0001ff, 0xc0000008, &DLSA             , 0,
        MIPS64_             },        /* DLSA */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000010, &NMD::DSLLV            , 0,
+       0xfc0001ff, 0xc0000010, &DSLLV            , 0,
        MIPS64_             },        /* DSLLV */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000018, &NMD::DMUL             , 0,
+       0xfc0001ff, 0xc0000018, &DMUL             , 0,
        MIPS64_             },        /* DMUL */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0xc0000020, 0                      , 0,
@@ -20558,10 +20558,10 @@ NMD::Pool NMD::POOL32S_0[64] = {
        0xfc0001ff, 0xc0000048, 0                      , 0,
        0x0                 },        /* POOL32S_0~*(9) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000050, &NMD::DSRLV            , 0,
+       0xfc0001ff, 0xc0000050, &DSRLV            , 0,
        MIPS64_             },        /* DSRLV */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000058, &NMD::DMUH             , 0,
+       0xfc0001ff, 0xc0000058, &DMUH             , 0,
        MIPS64_             },        /* DMUH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0xc0000060, 0                      , 0,
@@ -20582,10 +20582,10 @@ NMD::Pool NMD::POOL32S_0[64] = {
        0xfc0001ff, 0xc0000088, 0                      , 0,
        0x0                 },        /* POOL32S_0~*(17) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000090, &NMD::DSRAV            , 0,
+       0xfc0001ff, 0xc0000090, &DSRAV            , 0,
        MIPS64_             },        /* DSRAV */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000098, &NMD::DMULU            , 0,
+       0xfc0001ff, 0xc0000098, &DMULU            , 0,
        MIPS64_             },        /* DMULU */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0xc00000a0, 0                      , 0,
@@ -20606,10 +20606,10 @@ NMD::Pool NMD::POOL32S_0[64] = {
        0xfc0001ff, 0xc00000c8, 0                      , 0,
        0x0                 },        /* POOL32S_0~*(25) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc00000d0, &NMD::DROTRV           , 0,
+       0xfc0001ff, 0xc00000d0, &DROTRV           , 0,
        MIPS64_             },        /* DROTRV */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc00000d8, &NMD::DMUHU            , 0,
+       0xfc0001ff, 0xc00000d8, &DMUHU            , 0,
        MIPS64_             },        /* DMUHU */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0xc00000e0, 0                      , 0,
@@ -20630,10 +20630,10 @@ NMD::Pool NMD::POOL32S_0[64] = {
        0xfc0001ff, 0xc0000108, 0                      , 0,
        0x0                 },        /* POOL32S_0~*(33) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000110, &NMD::DADD             , 0,
+       0xfc0001ff, 0xc0000110, &DADD             , 0,
        MIPS64_             },        /* DADD */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000118, &NMD::DDIV             , 0,
+       0xfc0001ff, 0xc0000118, &DDIV             , 0,
        MIPS64_             },        /* DDIV */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0xc0000120, 0                      , 0,
@@ -20654,10 +20654,10 @@ NMD::Pool NMD::POOL32S_0[64] = {
        0xfc0001ff, 0xc0000148, 0                      , 0,
        0x0                 },        /* POOL32S_0~*(41) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000150, &NMD::DADDU            , 0,
+       0xfc0001ff, 0xc0000150, &DADDU            , 0,
        MIPS64_             },        /* DADDU */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000158, &NMD::DMOD             , 0,
+       0xfc0001ff, 0xc0000158, &DMOD             , 0,
        MIPS64_             },        /* DMOD */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0xc0000160, 0                      , 0,
@@ -20678,10 +20678,10 @@ NMD::Pool NMD::POOL32S_0[64] = {
        0xfc0001ff, 0xc0000188, 0                      , 0,
        0x0                 },        /* POOL32S_0~*(49) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000190, &NMD::DSUB             , 0,
+       0xfc0001ff, 0xc0000190, &DSUB             , 0,
        MIPS64_             },        /* DSUB */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc0000198, &NMD::DDIVU            , 0,
+       0xfc0001ff, 0xc0000198, &DDIVU            , 0,
        MIPS64_             },        /* DDIVU */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0xc00001a0, 0                      , 0,
@@ -20702,10 +20702,10 @@ NMD::Pool NMD::POOL32S_0[64] = {
        0xfc0001ff, 0xc00001c8, 0                      , 0,
        0x0                 },        /* POOL32S_0~*(57) */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc00001d0, &NMD::DSUBU            , 0,
+       0xfc0001ff, 0xc00001d0, &DSUBU            , 0,
        MIPS64_             },        /* DSUBU */
     { instruction         , 0                   , 0   , 32,
-       0xfc0001ff, 0xc00001d8, &NMD::DMODU            , 0,
+       0xfc0001ff, 0xc00001d8, &DMODU            , 0,
        MIPS64_             },        /* DMODU */
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0xc00001e0, 0                      , 0,
@@ -20835,7 +20835,7 @@ NMD::Pool NMD::POOL32Sxf_4[128] = {
        0xfc00ffff, 0xc000493c, 0                      , 0,
        0x0                 },        /* POOL32Sxf_4~*(36) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0xc0004b3c, &NMD::DCLO             , 0,
+       0xfc00ffff, 0xc0004b3c, &DCLO             , 0,
        MIPS64_             },        /* DCLO */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0xc0004d3c, 0                      , 0,
@@ -20859,7 +20859,7 @@ NMD::Pool NMD::POOL32Sxf_4[128] = {
        0xfc00ffff, 0xc000593c, 0                      , 0,
        0x0                 },        /* POOL32Sxf_4~*(44) */
     { instruction         , 0                   , 0   , 32,
-       0xfc00ffff, 0xc0005b3c, &NMD::DCLZ             , 0,
+       0xfc00ffff, 0xc0005b3c, &DCLZ             , 0,
        MIPS64_             },        /* DCLZ */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0xc0005d3c, 0                      , 0,
@@ -21140,10 +21140,10 @@ NMD::Pool NMD::POOL32Sxf[8] = {
 
 NMD::Pool NMD::POOL32S_4[8] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00003f, 0xc0000004, &NMD::EXTD             , 0,
+       0xfc00003f, 0xc0000004, &EXTD             , 0,
        MIPS64_             },        /* EXTD */
     { instruction         , 0                   , 0   , 32,
-       0xfc00003f, 0xc000000c, &NMD::EXTD32           , 0,
+       0xfc00003f, 0xc000000c, &EXTD32           , 0,
        MIPS64_             },        /* EXTD32 */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00003f, 0xc0000014, 0                      , 0,
@@ -21196,27 +21196,27 @@ NMD::Pool NMD::POOL32S[8] = {
 
 NMD::Pool NMD::P_LUI[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc000002, 0xe0000000, &NMD::LUI              , 0,
+       0xfc000002, 0xe0000000, &LUI              , 0,
        0x0                 },        /* LUI */
     { instruction         , 0                   , 0   , 32,
-       0xfc000002, 0xe0000002, &NMD::ALUIPC           , 0,
+       0xfc000002, 0xe0000002, &ALUIPC           , 0,
        0x0                 },        /* ALUIPC */
 };
 
 
 NMD::Pool NMD::P_GP_LH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0001, 0x44100000, &NMD::LH_GP_           , 0,
+       0xfc1c0001, 0x44100000, &LH_GP_           , 0,
        0x0                 },        /* LH[GP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0001, 0x44100001, &NMD::LHU_GP_          , 0,
+       0xfc1c0001, 0x44100001, &LHU_GP_          , 0,
        0x0                 },        /* LHU[GP] */
 };
 
 
 NMD::Pool NMD::P_GP_SH[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0001, 0x44140000, &NMD::SH_GP_           , 0,
+       0xfc1c0001, 0x44140000, &SH_GP_           , 0,
        0x0                 },        /* SH[GP] */
     { reserved_block      , 0                   , 0   , 32,
        0xfc1c0001, 0x44140001, 0                      , 0,
@@ -21226,23 +21226,23 @@ NMD::Pool NMD::P_GP_SH[2] = {
 
 NMD::Pool NMD::P_GP_CP1[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0003, 0x44180000, &NMD::LWC1_GP_         , 0,
+       0xfc1c0003, 0x44180000, &LWC1_GP_         , 0,
        CP1_                },        /* LWC1[GP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0003, 0x44180001, &NMD::SWC1_GP_         , 0,
+       0xfc1c0003, 0x44180001, &SWC1_GP_         , 0,
        CP1_                },        /* SWC1[GP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0003, 0x44180002, &NMD::LDC1_GP_         , 0,
+       0xfc1c0003, 0x44180002, &LDC1_GP_         , 0,
        CP1_                },        /* LDC1[GP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0003, 0x44180003, &NMD::SDC1_GP_         , 0,
+       0xfc1c0003, 0x44180003, &SDC1_GP_         , 0,
        CP1_                },        /* SDC1[GP] */
 };
 
 
 NMD::Pool NMD::P_GP_M64[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0003, 0x441c0000, &NMD::LWU_GP_          , 0,
+       0xfc1c0003, 0x441c0000, &LWU_GP_          , 0,
        MIPS64_             },        /* LWU[GP] */
     { reserved_block      , 0                   , 0   , 32,
        0xfc1c0003, 0x441c0001, 0                      , 0,
@@ -21258,16 +21258,16 @@ NMD::Pool NMD::P_GP_M64[4] = {
 
 NMD::Pool NMD::P_GP_BH[8] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0000, 0x44000000, &NMD::LB_GP_           , 0,
+       0xfc1c0000, 0x44000000, &LB_GP_           , 0,
        0x0                 },        /* LB[GP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0000, 0x44040000, &NMD::SB_GP_           , 0,
+       0xfc1c0000, 0x44040000, &SB_GP_           , 0,
        0x0                 },        /* SB[GP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0000, 0x44080000, &NMD::LBU_GP_          , 0,
+       0xfc1c0000, 0x44080000, &LBU_GP_          , 0,
        0x0                 },        /* LBU[GP] */
     { instruction         , 0                   , 0   , 32,
-       0xfc1c0000, 0x440c0000, &NMD::ADDIU_GP_B_      , 0,
+       0xfc1c0000, 0x440c0000, &ADDIU_GP_B_      , 0,
        0x0                 },        /* ADDIU[GP.B] */
     { pool                , P_GP_LH             , 2   , 32,
        0xfc1c0000, 0x44100000, 0                      , 0,
@@ -21286,134 +21286,134 @@ NMD::Pool NMD::P_GP_BH[8] = {
 
 NMD::Pool NMD::P_LS_U12[16] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x84000000, &NMD::LB_U12_          , 0,
+       0xfc00f000, 0x84000000, &LB_U12_          , 0,
        0x0                 },        /* LB[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x84001000, &NMD::SB_U12_          , 0,
+       0xfc00f000, 0x84001000, &SB_U12_          , 0,
        0x0                 },        /* SB[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x84002000, &NMD::LBU_U12_         , 0,
+       0xfc00f000, 0x84002000, &LBU_U12_         , 0,
        0x0                 },        /* LBU[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x84003000, &NMD::PREF_U12_        , 0,
+       0xfc00f000, 0x84003000, &PREF_U12_        , 0,
        0x0                 },        /* PREF[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x84004000, &NMD::LH_U12_          , 0,
+       0xfc00f000, 0x84004000, &LH_U12_          , 0,
        0x0                 },        /* LH[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x84005000, &NMD::SH_U12_          , 0,
+       0xfc00f000, 0x84005000, &SH_U12_          , 0,
        0x0                 },        /* SH[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x84006000, &NMD::LHU_U12_         , 0,
+       0xfc00f000, 0x84006000, &LHU_U12_         , 0,
        0x0                 },        /* LHU[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x84007000, &NMD::LWU_U12_         , 0,
+       0xfc00f000, 0x84007000, &LWU_U12_         , 0,
        MIPS64_             },        /* LWU[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x84008000, &NMD::LW_U12_          , 0,
+       0xfc00f000, 0x84008000, &LW_U12_          , 0,
        0x0                 },        /* LW[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x84009000, &NMD::SW_U12_          , 0,
+       0xfc00f000, 0x84009000, &SW_U12_          , 0,
        0x0                 },        /* SW[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x8400a000, &NMD::LWC1_U12_        , 0,
+       0xfc00f000, 0x8400a000, &LWC1_U12_        , 0,
        CP1_                },        /* LWC1[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x8400b000, &NMD::SWC1_U12_        , 0,
+       0xfc00f000, 0x8400b000, &SWC1_U12_        , 0,
        CP1_                },        /* SWC1[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x8400c000, &NMD::LD_U12_          , 0,
+       0xfc00f000, 0x8400c000, &LD_U12_          , 0,
        MIPS64_             },        /* LD[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x8400d000, &NMD::SD_U12_          , 0,
+       0xfc00f000, 0x8400d000, &SD_U12_          , 0,
        MIPS64_             },        /* SD[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x8400e000, &NMD::LDC1_U12_        , 0,
+       0xfc00f000, 0x8400e000, &LDC1_U12_        , 0,
        CP1_                },        /* LDC1[U12] */
     { instruction         , 0                   , 0   , 32,
-       0xfc00f000, 0x8400f000, &NMD::SDC1_U12_        , 0,
+       0xfc00f000, 0x8400f000, &SDC1_U12_        , 0,
        CP1_                },        /* SDC1[U12] */
 };
 
 
 NMD::Pool NMD::P_PREF_S9_[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xffe07f00, 0xa7e01800, &NMD::SYNCI            , 0,
+       0xffe07f00, 0xa7e01800, &SYNCI            , 0,
        0x0                 },        /* SYNCI */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4001800, &NMD::PREF_S9_         , &PREF_S9__cond    ,
+       0xfc007f00, 0xa4001800, &PREF_S9_         , &PREF_S9__cond    ,
        0x0                 },        /* PREF[S9] */
 };
 
 
 NMD::Pool NMD::P_LS_S0[16] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4000000, &NMD::LB_S9_           , 0,
+       0xfc007f00, 0xa4000000, &LB_S9_           , 0,
        0x0                 },        /* LB[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4000800, &NMD::SB_S9_           , 0,
+       0xfc007f00, 0xa4000800, &SB_S9_           , 0,
        0x0                 },        /* SB[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4001000, &NMD::LBU_S9_          , 0,
+       0xfc007f00, 0xa4001000, &LBU_S9_          , 0,
        0x0                 },        /* LBU[S9] */
     { pool                , P_PREF_S9_          , 2   , 32,
        0xfc007f00, 0xa4001800, 0                      , 0,
        0x0                 },        /* P.PREF[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4002000, &NMD::LH_S9_           , 0,
+       0xfc007f00, 0xa4002000, &LH_S9_           , 0,
        0x0                 },        /* LH[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4002800, &NMD::SH_S9_           , 0,
+       0xfc007f00, 0xa4002800, &SH_S9_           , 0,
        0x0                 },        /* SH[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4003000, &NMD::LHU_S9_          , 0,
+       0xfc007f00, 0xa4003000, &LHU_S9_          , 0,
        0x0                 },        /* LHU[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4003800, &NMD::LWU_S9_          , 0,
+       0xfc007f00, 0xa4003800, &LWU_S9_          , 0,
        MIPS64_             },        /* LWU[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4004000, &NMD::LW_S9_           , 0,
+       0xfc007f00, 0xa4004000, &LW_S9_           , 0,
        0x0                 },        /* LW[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4004800, &NMD::SW_S9_           , 0,
+       0xfc007f00, 0xa4004800, &SW_S9_           , 0,
        0x0                 },        /* SW[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4005000, &NMD::LWC1_S9_         , 0,
+       0xfc007f00, 0xa4005000, &LWC1_S9_         , 0,
        CP1_                },        /* LWC1[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4005800, &NMD::SWC1_S9_         , 0,
+       0xfc007f00, 0xa4005800, &SWC1_S9_         , 0,
        CP1_                },        /* SWC1[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4006000, &NMD::LD_S9_           , 0,
+       0xfc007f00, 0xa4006000, &LD_S9_           , 0,
        MIPS64_             },        /* LD[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4006800, &NMD::SD_S9_           , 0,
+       0xfc007f00, 0xa4006800, &SD_S9_           , 0,
        MIPS64_             },        /* SD[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4007000, &NMD::LDC1_S9_         , 0,
+       0xfc007f00, 0xa4007000, &LDC1_S9_         , 0,
        CP1_                },        /* LDC1[S9] */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4007800, &NMD::SDC1_S9_         , 0,
+       0xfc007f00, 0xa4007800, &SDC1_S9_         , 0,
        CP1_                },        /* SDC1[S9] */
 };
 
 
 NMD::Pool NMD::ASET_ACLR[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfe007f00, 0xa4001100, &NMD::ASET             , 0,
+       0xfe007f00, 0xa4001100, &ASET             , 0,
        MCU_                },        /* ASET */
     { instruction         , 0                   , 0   , 32,
-       0xfe007f00, 0xa6001100, &NMD::ACLR             , 0,
+       0xfe007f00, 0xa6001100, &ACLR             , 0,
        MCU_                },        /* ACLR */
 };
 
 
 NMD::Pool NMD::P_LL[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007f03, 0xa4005100, &NMD::LL               , 0,
+       0xfc007f03, 0xa4005100, &LL               , 0,
        0x0                 },        /* LL */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f03, 0xa4005101, &NMD::LLWP             , 0,
+       0xfc007f03, 0xa4005101, &LLWP             , 0,
        XNP_                },        /* LLWP */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007f03, 0xa4005102, 0                      , 0,
@@ -21426,10 +21426,10 @@ NMD::Pool NMD::P_LL[4] = {
 
 NMD::Pool NMD::P_SC[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007f03, 0xa4005900, &NMD::SC               , 0,
+       0xfc007f03, 0xa4005900, &SC               , 0,
        0x0                 },        /* SC */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f03, 0xa4005901, &NMD::SCWP             , 0,
+       0xfc007f03, 0xa4005901, &SCWP             , 0,
        XNP_                },        /* SCWP */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007f03, 0xa4005902, 0                      , 0,
@@ -21442,10 +21442,10 @@ NMD::Pool NMD::P_SC[4] = {
 
 NMD::Pool NMD::P_LLD[8] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007f07, 0xa4007100, &NMD::LLD              , 0,
+       0xfc007f07, 0xa4007100, &LLD              , 0,
        MIPS64_             },        /* LLD */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f07, 0xa4007101, &NMD::LLDP             , 0,
+       0xfc007f07, 0xa4007101, &LLDP             , 0,
        MIPS64_             },        /* LLDP */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007f07, 0xa4007102, 0                      , 0,
@@ -21470,10 +21470,10 @@ NMD::Pool NMD::P_LLD[8] = {
 
 NMD::Pool NMD::P_SCD[8] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007f07, 0xa4007900, &NMD::SCD              , 0,
+       0xfc007f07, 0xa4007900, &SCD              , 0,
        MIPS64_             },        /* SCD */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f07, 0xa4007901, &NMD::SCDP             , 0,
+       0xfc007f07, 0xa4007901, &SCDP             , 0,
        MIPS64_             },        /* SCDP */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007f07, 0xa4007902, 0                      , 0,
@@ -21510,22 +21510,22 @@ NMD::Pool NMD::P_LS_S1[16] = {
        0xfc007f00, 0xa4001900, 0                      , 0,
        0x0                 },        /* P.LS.S1~*(3) */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4002100, &NMD::UALH             , 0,
+       0xfc007f00, 0xa4002100, &UALH             , 0,
        XMMS_               },        /* UALH */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4002900, &NMD::UASH             , 0,
+       0xfc007f00, 0xa4002900, &UASH             , 0,
        XMMS_               },        /* UASH */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007f00, 0xa4003100, 0                      , 0,
        0x0                 },        /* P.LS.S1~*(6) */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4003900, &NMD::CACHE            , 0,
+       0xfc007f00, 0xa4003900, &CACHE            , 0,
        CP0_                },        /* CACHE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4004100, &NMD::LWC2             , 0,
+       0xfc007f00, 0xa4004100, &LWC2             , 0,
        CP2_                },        /* LWC2 */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4004900, &NMD::SWC2             , 0,
+       0xfc007f00, 0xa4004900, &SWC2             , 0,
        CP2_                },        /* SWC2 */
     { pool                , P_LL                , 4   , 32,
        0xfc007f00, 0xa4005100, 0                      , 0,
@@ -21534,10 +21534,10 @@ NMD::Pool NMD::P_LS_S1[16] = {
        0xfc007f00, 0xa4005900, 0                      , 0,
        0x0                 },        /* P.SC */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4006100, &NMD::LDC2             , 0,
+       0xfc007f00, 0xa4006100, &LDC2             , 0,
        CP2_                },        /* LDC2 */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4006900, &NMD::SDC2             , 0,
+       0xfc007f00, 0xa4006900, &SDC2             , 0,
        CP2_                },        /* SDC2 */
     { pool                , P_LLD               , 8   , 32,
        0xfc007f00, 0xa4007100, 0                      , 0,
@@ -21550,20 +21550,20 @@ NMD::Pool NMD::P_LS_S1[16] = {
 
 NMD::Pool NMD::P_PREFE[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xffe07f00, 0xa7e01a00, &NMD::SYNCIE           , 0,
+       0xffe07f00, 0xa7e01a00, &SYNCIE           , 0,
        CP0_ | EVA_         },        /* SYNCIE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4001a00, &NMD::PREFE            , &PREFE_cond       ,
+       0xfc007f00, 0xa4001a00, &PREFE            , &PREFE_cond       ,
        CP0_ | EVA_         },        /* PREFE */
 };
 
 
 NMD::Pool NMD::P_LLE[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007f03, 0xa4005200, &NMD::LLE              , 0,
+       0xfc007f03, 0xa4005200, &LLE              , 0,
        CP0_ | EVA_         },        /* LLE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f03, 0xa4005201, &NMD::LLWPE            , 0,
+       0xfc007f03, 0xa4005201, &LLWPE            , 0,
        CP0_ | EVA_         },        /* LLWPE */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007f03, 0xa4005202, 0                      , 0,
@@ -21576,10 +21576,10 @@ NMD::Pool NMD::P_LLE[4] = {
 
 NMD::Pool NMD::P_SCE[4] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007f03, 0xa4005a00, &NMD::SCE              , 0,
+       0xfc007f03, 0xa4005a00, &SCE              , 0,
        CP0_ | EVA_         },        /* SCE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f03, 0xa4005a01, &NMD::SCWPE            , 0,
+       0xfc007f03, 0xa4005a01, &SCWPE            , 0,
        CP0_ | EVA_         },        /* SCWPE */
     { reserved_block      , 0                   , 0   , 32,
        0xfc007f03, 0xa4005a02, 0                      , 0,
@@ -21592,34 +21592,34 @@ NMD::Pool NMD::P_SCE[4] = {
 
 NMD::Pool NMD::P_LS_E0[16] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4000200, &NMD::LBE              , 0,
+       0xfc007f00, 0xa4000200, &LBE              , 0,
        CP0_ | EVA_         },        /* LBE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4000a00, &NMD::SBE              , 0,
+       0xfc007f00, 0xa4000a00, &SBE              , 0,
        CP0_ | EVA_         },        /* SBE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4001200, &NMD::LBUE             , 0,
+       0xfc007f00, 0xa4001200, &LBUE             , 0,
        CP0_ | EVA_         },        /* LBUE */
     { pool                , P_PREFE             , 2   , 32,
        0xfc007f00, 0xa4001a00, 0                      , 0,
        0x0                 },        /* P.PREFE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4002200, &NMD::LHE              , 0,
+       0xfc007f00, 0xa4002200, &LHE              , 0,
        CP0_ | EVA_         },        /* LHE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4002a00, &NMD::SHE              , 0,
+       0xfc007f00, 0xa4002a00, &SHE              , 0,
        CP0_ | EVA_         },        /* SHE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4003200, &NMD::LHUE             , 0,
+       0xfc007f00, 0xa4003200, &LHUE             , 0,
        CP0_ | EVA_         },        /* LHUE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4003a00, &NMD::CACHEE           , 0,
+       0xfc007f00, 0xa4003a00, &CACHEE           , 0,
        CP0_ | EVA_         },        /* CACHEE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4004200, &NMD::LWE              , 0,
+       0xfc007f00, 0xa4004200, &LWE              , 0,
        CP0_ | EVA_         },        /* LWE */
     { instruction         , 0                   , 0   , 32,
-       0xfc007f00, 0xa4004a00, &NMD::SWE              , 0,
+       0xfc007f00, 0xa4004a00, &SWE              , 0,
        CP0_ | EVA_         },        /* SWE */
     { pool                , P_LLE               , 4   , 32,
        0xfc007f00, 0xa4005200, 0                      , 0,
@@ -21644,40 +21644,40 @@ NMD::Pool NMD::P_LS_E0[16] = {
 
 NMD::Pool NMD::P_LS_WM[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc000f00, 0xa4000400, &NMD::LWM              , 0,
+       0xfc000f00, 0xa4000400, &LWM              , 0,
        XMMS_               },        /* LWM */
     { instruction         , 0                   , 0   , 32,
-       0xfc000f00, 0xa4000c00, &NMD::SWM              , 0,
+       0xfc000f00, 0xa4000c00, &SWM              , 0,
        XMMS_               },        /* SWM */
 };
 
 
 NMD::Pool NMD::P_LS_UAWM[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc000f00, 0xa4000500, &NMD::UALWM            , 0,
+       0xfc000f00, 0xa4000500, &UALWM            , 0,
        XMMS_               },        /* UALWM */
     { instruction         , 0                   , 0   , 32,
-       0xfc000f00, 0xa4000d00, &NMD::UASWM            , 0,
+       0xfc000f00, 0xa4000d00, &UASWM            , 0,
        XMMS_               },        /* UASWM */
 };
 
 
 NMD::Pool NMD::P_LS_DM[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc000f00, 0xa4000600, &NMD::LDM              , 0,
+       0xfc000f00, 0xa4000600, &LDM              , 0,
        MIPS64_             },        /* LDM */
     { instruction         , 0                   , 0   , 32,
-       0xfc000f00, 0xa4000e00, &NMD::SDM              , 0,
+       0xfc000f00, 0xa4000e00, &SDM              , 0,
        MIPS64_             },        /* SDM */
 };
 
 
 NMD::Pool NMD::P_LS_UADM[2] = {
     { instruction         , 0                   , 0   , 32,
-       0xfc000f00, 0xa4000700, &NMD::UALDM            , 0,
+       0xfc000f00, 0xa4000700, &UALDM            , 0,
        MIPS64_             },        /* UALDM */
     { instruction         , 0                   , 0   , 32,
-       0xfc000f00, 0xa4000f00, &NMD::UASDM            , 0,
+       0xfc000f00, 0xa4000f00, &UASDM            , 0,
        MIPS64_             },        /* UASDM */
 };
 
@@ -21712,30 +21712,30 @@ NMD::Pool NMD::P_LS_S9[8] = {
 
 NMD::Pool NMD::P_BAL[2] = {
     { branch_instruction  , 0                   , 0   , 32,
-       0xfe000000, 0x28000000, &NMD::BC_32_           , 0,
+       0xfe000000, 0x28000000, &BC_32_           , 0,
        0x0                 },        /* BC[32] */
     { call_instruction    , 0                   , 0   , 32,
-       0xfe000000, 0x2a000000, &NMD::BALC_32_         , 0,
+       0xfe000000, 0x2a000000, &BALC_32_         , 0,
        0x0                 },        /* BALC[32] */
 };
 
 
 NMD::Pool NMD::P_BALRSC[2] = {
     { branch_instruction  , 0                   , 0   , 32,
-       0xffe0f000, 0x48008000, &NMD::BRSC             , 0,
+       0xffe0f000, 0x48008000, &BRSC             , 0,
        0x0                 },        /* BRSC */
     { call_instruction    , 0                   , 0   , 32,
-       0xfc00f000, 0x48008000, &NMD::BALRSC           , &BALRSC_cond      ,
+       0xfc00f000, 0x48008000, &BALRSC           , &BALRSC_cond      ,
        0x0                 },        /* BALRSC */
 };
 
 
 NMD::Pool NMD::P_J[16] = {
     { call_instruction    , 0                   , 0   , 32,
-       0xfc00f000, 0x48000000, &NMD::JALRC_32_        , 0,
+       0xfc00f000, 0x48000000, &JALRC_32_        , 0,
        0x0                 },        /* JALRC[32] */
     { call_instruction    , 0                   , 0   , 32,
-       0xfc00f000, 0x48001000, &NMD::JALRC_HB         , 0,
+       0xfc00f000, 0x48001000, &JALRC_HB         , 0,
        0x0                 },        /* JALRC.HB */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00f000, 0x48002000, 0                      , 0,
@@ -21784,19 +21784,19 @@ NMD::Pool NMD::P_J[16] = {
 
 NMD::Pool NMD::P_BR3A[32] = {
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1fc000, 0x88004000, &NMD::BC1EQZC          , 0,
+       0xfc1fc000, 0x88004000, &BC1EQZC          , 0,
        CP1_                },        /* BC1EQZC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1fc000, 0x88014000, &NMD::BC1NEZC          , 0,
+       0xfc1fc000, 0x88014000, &BC1NEZC          , 0,
        CP1_                },        /* BC1NEZC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1fc000, 0x88024000, &NMD::BC2EQZC          , 0,
+       0xfc1fc000, 0x88024000, &BC2EQZC          , 0,
        CP2_                },        /* BC2EQZC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1fc000, 0x88034000, &NMD::BC2NEZC          , 0,
+       0xfc1fc000, 0x88034000, &BC2NEZC          , 0,
        CP2_                },        /* BC2NEZC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1fc000, 0x88044000, &NMD::BPOSGE32C        , 0,
+       0xfc1fc000, 0x88044000, &BPOSGE32C        , 0,
        DSP_                },        /* BPOSGE32C */
     { reserved_block      , 0                   , 0   , 32,
        0xfc1fc000, 0x88054000, 0                      , 0,
@@ -21884,60 +21884,60 @@ NMD::Pool NMD::P_BR3A[32] = {
 
 NMD::Pool NMD::P_BR1[4] = {
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc00c000, 0x88000000, &NMD::BEQC_32_         , 0,
+       0xfc00c000, 0x88000000, &BEQC_32_         , 0,
        0x0                 },        /* BEQC[32] */
     { pool                , P_BR3A              , 32  , 32,
        0xfc00c000, 0x88004000, 0                      , 0,
        0x0                 },        /* P.BR3A */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc00c000, 0x88008000, &NMD::BGEC             , 0,
+       0xfc00c000, 0x88008000, &BGEC             , 0,
        0x0                 },        /* BGEC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc00c000, 0x8800c000, &NMD::BGEUC            , 0,
+       0xfc00c000, 0x8800c000, &BGEUC            , 0,
        0x0                 },        /* BGEUC */
 };
 
 
 NMD::Pool NMD::P_BR2[4] = {
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc00c000, 0xa8000000, &NMD::BNEC_32_         , 0,
+       0xfc00c000, 0xa8000000, &BNEC_32_         , 0,
        0x0                 },        /* BNEC[32] */
     { reserved_block      , 0                   , 0   , 32,
        0xfc00c000, 0xa8004000, 0                      , 0,
        0x0                 },        /* P.BR2~*(1) */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc00c000, 0xa8008000, &NMD::BLTC             , 0,
+       0xfc00c000, 0xa8008000, &BLTC             , 0,
        0x0                 },        /* BLTC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc00c000, 0xa800c000, &NMD::BLTUC            , 0,
+       0xfc00c000, 0xa800c000, &BLTUC            , 0,
        0x0                 },        /* BLTUC */
 };
 
 
 NMD::Pool NMD::P_BRI[8] = {
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1c0000, 0xc8000000, &NMD::BEQIC            , 0,
+       0xfc1c0000, 0xc8000000, &BEQIC            , 0,
        0x0                 },        /* BEQIC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1c0000, 0xc8040000, &NMD::BBEQZC           , 0,
+       0xfc1c0000, 0xc8040000, &BBEQZC           , 0,
        XMMS_               },        /* BBEQZC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1c0000, 0xc8080000, &NMD::BGEIC            , 0,
+       0xfc1c0000, 0xc8080000, &BGEIC            , 0,
        0x0                 },        /* BGEIC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1c0000, 0xc80c0000, &NMD::BGEIUC           , 0,
+       0xfc1c0000, 0xc80c0000, &BGEIUC           , 0,
        0x0                 },        /* BGEIUC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1c0000, 0xc8100000, &NMD::BNEIC            , 0,
+       0xfc1c0000, 0xc8100000, &BNEIC            , 0,
        0x0                 },        /* BNEIC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1c0000, 0xc8140000, &NMD::BBNEZC           , 0,
+       0xfc1c0000, 0xc8140000, &BBNEZC           , 0,
        XMMS_               },        /* BBNEZC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1c0000, 0xc8180000, &NMD::BLTIC            , 0,
+       0xfc1c0000, 0xc8180000, &BLTIC            , 0,
        0x0                 },        /* BLTIC */
     { branch_instruction  , 0                   , 0   , 32,
-       0xfc1c0000, 0xc81c0000, &NMD::BLTIUC           , 0,
+       0xfc1c0000, 0xc81c0000, &BLTIUC           , 0,
        0x0                 },        /* BLTIUC */
 };
 
@@ -21968,7 +21968,7 @@ NMD::Pool NMD::P32[32] = {
        0xfc000000, 0xe0000000, 0                      , 0,
        0x0                 },        /* P.LUI */
     { instruction         , 0                   , 0   , 32,
-       0xfc000000, 0x04000000, &NMD::ADDIUPC_32_      , 0,
+       0xfc000000, 0x04000000, &ADDIUPC_32_      , 0,
        0x0                 },        /* ADDIUPC[32] */
     { reserved_block      , 0                   , 0   , 32,
        0xfc000000, 0x24000000, 0                      , 0,
@@ -21992,7 +21992,7 @@ NMD::Pool NMD::P32[32] = {
        0xfc000000, 0xe4000000, 0                      , 0,
        0x0                 },        /* P32~*(29) */
     { call_instruction    , 0                   , 0   , 32,
-       0xfc000000, 0x08000000, &NMD::MOVE_BALC        , 0,
+       0xfc000000, 0x08000000, &MOVE_BALC        , 0,
        XMMS_               },        /* MOVE.BALC */
     { pool                , P_BAL               , 2   , 32,
        0xfc000000, 0x28000000, 0                      , 0,
@@ -22044,10 +22044,10 @@ NMD::Pool NMD::P32[32] = {
 
 NMD::Pool NMD::P16_SYSCALL[2] = {
     { instruction         , 0                   , 0   , 16,
-       0xfffc    , 0x1008    , &NMD::SYSCALL_16_      , 0,
+       0xfffc    , 0x1008    , &SYSCALL_16_      , 0,
        0x0                 },        /* SYSCALL[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfffc    , 0x100c    , &NMD::HYPCALL_16_      , 0,
+       0xfffc    , 0x100c    , &HYPCALL_16_      , 0,
        CP0_ | VZ_          },        /* HYPCALL[16] */
 };
 
@@ -22060,10 +22060,10 @@ NMD::Pool NMD::P16_RI[4] = {
        0xfff8    , 0x1008    , 0                      , 0,
        0x0                 },        /* P16.SYSCALL */
     { instruction         , 0                   , 0   , 16,
-       0xfff8    , 0x1010    , &NMD::BREAK_16_        , 0,
+       0xfff8    , 0x1010    , &BREAK_16_        , 0,
        0x0                 },        /* BREAK[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfff8    , 0x1018    , &NMD::SDBBP_16_        , 0,
+       0xfff8    , 0x1018    , &SDBBP_16_        , 0,
        EJTAG_              },        /* SDBBP[16] */
 };
 
@@ -22073,33 +22073,33 @@ NMD::Pool NMD::P16_MV[2] = {
        0xffe0    , 0x1000    , 0                      , 0,
        0x0                 },        /* P16.RI */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0x1000    , &NMD::MOVE             , &MOVE_cond        ,
+       0xfc00    , 0x1000    , &MOVE             , &MOVE_cond        ,
        0x0                 },        /* MOVE */
 };
 
 
 NMD::Pool NMD::P16_SHIFT[2] = {
     { instruction         , 0                   , 0   , 16,
-       0xfc08    , 0x3000    , &NMD::SLL_16_          , 0,
+       0xfc08    , 0x3000    , &SLL_16_          , 0,
        0x0                 },        /* SLL[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc08    , 0x3008    , &NMD::SRL_16_          , 0,
+       0xfc08    , 0x3008    , &SRL_16_          , 0,
        0x0                 },        /* SRL[16] */
 };
 
 
 NMD::Pool NMD::POOL16C_00[4] = {
     { instruction         , 0                   , 0   , 16,
-       0xfc0f    , 0x5000    , &NMD::NOT_16_          , 0,
+       0xfc0f    , 0x5000    , &NOT_16_          , 0,
        0x0                 },        /* NOT[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc0f    , 0x5004    , &NMD::XOR_16_          , 0,
+       0xfc0f    , 0x5004    , &XOR_16_          , 0,
        0x0                 },        /* XOR[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc0f    , 0x5008    , &NMD::AND_16_          , 0,
+       0xfc0f    , 0x5008    , &AND_16_          , 0,
        0x0                 },        /* AND[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc0f    , 0x500c    , &NMD::OR_16_           , 0,
+       0xfc0f    , 0x500c    , &OR_16_           , 0,
        0x0                 },        /* OR[16] */
 };
 
@@ -22119,7 +22119,7 @@ NMD::Pool NMD::P16C[2] = {
        0xfc01    , 0x5000    , 0                      , 0,
        0x0                 },        /* POOL16C_0 */
     { instruction         , 0                   , 0   , 16,
-       0xfc01    , 0x5001    , &NMD::LWXS_16_         , 0,
+       0xfc01    , 0x5001    , &LWXS_16_         , 0,
        0x0                 },        /* LWXS[16] */
 };
 
@@ -22129,24 +22129,24 @@ NMD::Pool NMD::P16_A1[2] = {
        0xfc40    , 0x7000    , 0                      , 0,
        0x0                 },        /* P16.A1~*(0) */
     { instruction         , 0                   , 0   , 16,
-       0xfc40    , 0x7040    , &NMD::ADDIU_R1_SP_     , 0,
+       0xfc40    , 0x7040    , &ADDIU_R1_SP_     , 0,
        0x0                 },        /* ADDIU[R1.SP] */
 };
 
 
 NMD::Pool NMD::P_ADDIU_RS5_[2] = {
     { instruction         , 0                   , 0   , 16,
-       0xffe8    , 0x9008    , &NMD::NOP_16_          , 0,
+       0xffe8    , 0x9008    , &NOP_16_          , 0,
        0x0                 },        /* NOP[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc08    , 0x9008    , &NMD::ADDIU_RS5_       , &ADDIU_RS5__cond  ,
+       0xfc08    , 0x9008    , &ADDIU_RS5_       , &ADDIU_RS5__cond  ,
        0x0                 },        /* ADDIU[RS5] */
 };
 
 
 NMD::Pool NMD::P16_A2[2] = {
     { instruction         , 0                   , 0   , 16,
-       0xfc08    , 0x9000    , &NMD::ADDIU_R2_        , 0,
+       0xfc08    , 0x9000    , &ADDIU_R2_        , 0,
        0x0                 },        /* ADDIU[R2] */
     { pool                , P_ADDIU_RS5_        , 2   , 16,
        0xfc08    , 0x9008    , 0                      , 0,
@@ -22156,30 +22156,30 @@ NMD::Pool NMD::P16_A2[2] = {
 
 NMD::Pool NMD::P16_ADDU[2] = {
     { instruction         , 0                   , 0   , 16,
-       0xfc01    , 0xb000    , &NMD::ADDU_16_         , 0,
+       0xfc01    , 0xb000    , &ADDU_16_         , 0,
        0x0                 },        /* ADDU[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc01    , 0xb001    , &NMD::SUBU_16_         , 0,
+       0xfc01    , 0xb001    , &SUBU_16_         , 0,
        0x0                 },        /* SUBU[16] */
 };
 
 
 NMD::Pool NMD::P16_JRC[2] = {
     { branch_instruction  , 0                   , 0   , 16,
-       0xfc1f    , 0xd800    , &NMD::JRC              , 0,
+       0xfc1f    , 0xd800    , &JRC              , 0,
        0x0                 },        /* JRC */
     { call_instruction    , 0                   , 0   , 16,
-       0xfc1f    , 0xd810    , &NMD::JALRC_16_        , 0,
+       0xfc1f    , 0xd810    , &JALRC_16_        , 0,
        0x0                 },        /* JALRC[16] */
 };
 
 
 NMD::Pool NMD::P16_BR1[2] = {
     { branch_instruction  , 0                   , 0   , 16,
-       0xfc00    , 0xd800    , &NMD::BEQC_16_         , &BEQC_16__cond    ,
+       0xfc00    , 0xd800    , &BEQC_16_         , &BEQC_16__cond    ,
        XMMS_               },        /* BEQC[16] */
     { branch_instruction  , 0                   , 0   , 16,
-       0xfc00    , 0xd800    , &NMD::BNEC_16_         , &BNEC_16__cond    ,
+       0xfc00    , 0xd800    , &BNEC_16_         , &BNEC_16__cond    ,
        XMMS_               },        /* BNEC[16] */
 };
 
@@ -22196,20 +22196,20 @@ NMD::Pool NMD::P16_BR[2] = {
 
 NMD::Pool NMD::P16_SR[2] = {
     { instruction         , 0                   , 0   , 16,
-       0xfd00    , 0x1c00    , &NMD::SAVE_16_         , 0,
+       0xfd00    , 0x1c00    , &SAVE_16_         , 0,
        0x0                 },        /* SAVE[16] */
     { return_instruction  , 0                   , 0   , 16,
-       0xfd00    , 0x1d00    , &NMD::RESTORE_JRC_16_  , 0,
+       0xfd00    , 0x1d00    , &RESTORE_JRC_16_  , 0,
        0x0                 },        /* RESTORE.JRC[16] */
 };
 
 
 NMD::Pool NMD::P16_4X4[4] = {
     { instruction         , 0                   , 0   , 16,
-       0xfd08    , 0x3c00    , &NMD::ADDU_4X4_        , 0,
+       0xfd08    , 0x3c00    , &ADDU_4X4_        , 0,
        XMMS_               },        /* ADDU[4X4] */
     { instruction         , 0                   , 0   , 16,
-       0xfd08    , 0x3c08    , &NMD::MUL_4X4_         , 0,
+       0xfd08    , 0x3c08    , &MUL_4X4_         , 0,
        XMMS_               },        /* MUL[4X4] */
     { reserved_block      , 0                   , 0   , 16,
        0xfd08    , 0x3d00    , 0                      , 0,
@@ -22222,13 +22222,13 @@ NMD::Pool NMD::P16_4X4[4] = {
 
 NMD::Pool NMD::P16_LB[4] = {
     { instruction         , 0                   , 0   , 16,
-       0xfc0c    , 0x5c00    , &NMD::LB_16_           , 0,
+       0xfc0c    , 0x5c00    , &LB_16_           , 0,
        0x0                 },        /* LB[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc0c    , 0x5c04    , &NMD::SB_16_           , 0,
+       0xfc0c    , 0x5c04    , &SB_16_           , 0,
        0x0                 },        /* SB[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc0c    , 0x5c08    , &NMD::LBU_16_          , 0,
+       0xfc0c    , 0x5c08    , &LBU_16_          , 0,
        0x0                 },        /* LBU[16] */
     { reserved_block      , 0                   , 0   , 16,
        0xfc0c    , 0x5c0c    , 0                      , 0,
@@ -22238,13 +22238,13 @@ NMD::Pool NMD::P16_LB[4] = {
 
 NMD::Pool NMD::P16_LH[4] = {
     { instruction         , 0                   , 0   , 16,
-       0xfc09    , 0x7c00    , &NMD::LH_16_           , 0,
+       0xfc09    , 0x7c00    , &LH_16_           , 0,
        0x0                 },        /* LH[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc09    , 0x7c01    , &NMD::SH_16_           , 0,
+       0xfc09    , 0x7c01    , &SH_16_           , 0,
        0x0                 },        /* SH[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc09    , 0x7c08    , &NMD::LHU_16_          , 0,
+       0xfc09    , 0x7c08    , &LHU_16_          , 0,
        0x0                 },        /* LHU[16] */
     { reserved_block      , 0                   , 0   , 16,
        0xfc09    , 0x7c09    , 0                      , 0,
@@ -22272,40 +22272,40 @@ NMD::Pool NMD::P16[32] = {
        0xfc00    , 0xb000    , 0                      , 0,
        0x0                 },        /* P16.ADDU */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0xd000    , &NMD::LI_16_           , 0,
+       0xfc00    , 0xd000    , &LI_16_           , 0,
        0x0                 },        /* LI[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0xf000    , &NMD::ANDI_16_         , 0,
+       0xfc00    , 0xf000    , &ANDI_16_         , 0,
        0x0                 },        /* ANDI[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0x1400    , &NMD::LW_16_           , 0,
+       0xfc00    , 0x1400    , &LW_16_           , 0,
        0x0                 },        /* LW[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0x3400    , &NMD::LW_SP_           , 0,
+       0xfc00    , 0x3400    , &LW_SP_           , 0,
        0x0                 },        /* LW[SP] */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0x5400    , &NMD::LW_GP16_         , 0,
+       0xfc00    , 0x5400    , &LW_GP16_         , 0,
        0x0                 },        /* LW[GP16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0x7400    , &NMD::LW_4X4_          , 0,
+       0xfc00    , 0x7400    , &LW_4X4_          , 0,
        XMMS_               },        /* LW[4X4] */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0x9400    , &NMD::SW_16_           , 0,
+       0xfc00    , 0x9400    , &SW_16_           , 0,
        0x0                 },        /* SW[16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0xb400    , &NMD::SW_SP_           , 0,
+       0xfc00    , 0xb400    , &SW_SP_           , 0,
        0x0                 },        /* SW[SP] */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0xd400    , &NMD::SW_GP16_         , 0,
+       0xfc00    , 0xd400    , &SW_GP16_         , 0,
        0x0                 },        /* SW[GP16] */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0xf400    , &NMD::SW_4X4_          , 0,
+       0xfc00    , 0xf400    , &SW_4X4_          , 0,
        XMMS_               },        /* SW[4X4] */
     { branch_instruction  , 0                   , 0   , 16,
-       0xfc00    , 0x1800    , &NMD::BC_16_           , 0,
+       0xfc00    , 0x1800    , &BC_16_           , 0,
        0x0                 },        /* BC[16] */
     { call_instruction    , 0                   , 0   , 16,
-       0xfc00    , 0x3800    , &NMD::BALC_16_         , 0,
+       0xfc00    , 0x3800    , &BALC_16_         , 0,
        0x0                 },        /* BALC[16] */
     { reserved_block      , 0                   , 0   , 16,
        0xfc00    , 0x5800    , 0                      , 0,
@@ -22314,10 +22314,10 @@ NMD::Pool NMD::P16[32] = {
        0xfc00    , 0x7800    , 0                      , 0,
        0x0                 },        /* P16~*(14) */
     { branch_instruction  , 0                   , 0   , 16,
-       0xfc00    , 0x9800    , &NMD::BEQZC_16_        , 0,
+       0xfc00    , 0x9800    , &BEQZC_16_        , 0,
        0x0                 },        /* BEQZC[16] */
     { branch_instruction  , 0                   , 0   , 16,
-       0xfc00    , 0xb800    , &NMD::BNEZC_16_        , 0,
+       0xfc00    , 0xb800    , &BNEZC_16_        , 0,
        0x0                 },        /* BNEZC[16] */
     { pool                , P16_BR              , 2   , 16,
        0xfc00    , 0xd800    , 0                      , 0,
@@ -22341,13 +22341,13 @@ NMD::Pool NMD::P16[32] = {
        0xfc00    , 0x9c00    , 0                      , 0,
        0x0                 },        /* P16~*(19) */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0xbc00    , &NMD::MOVEP            , 0,
+       0xfc00    , 0xbc00    , &MOVEP            , 0,
        XMMS_               },        /* MOVEP */
     { reserved_block      , 0                   , 0   , 16,
        0xfc00    , 0xdc00    , 0                      , 0,
        0x0                 },        /* P16~*(27) */
     { instruction         , 0                   , 0   , 16,
-       0xfc00    , 0xfc00    , &NMD::MOVEP_REV_       , 0,
+       0xfc00    , 0xfc00    , &MOVEP_REV_       , 0,
        XMMS_               },        /* MOVEP[REV] */
 };
 
diff --git a/disas/nanomips.h b/disas/nanomips.h
index ff91fbf8c6..dead0bcb94 100644
--- a/disas/nanomips.h
+++ b/disas/nanomips.h
@@ -32,6 +32,8 @@ typedef uint16_t uint16;
 typedef uint64_t img_address;
 
 typedef bool (*conditional_function)(uint64 instruction);
+typedef std::string (*disassembly_function)(uint64 instruction,
+                                            img_address m_pc);
 
 enum TABLE_ENTRY_TYPE {
     instruction,
@@ -72,9 +74,6 @@ public:
 
 private:
 
-    typedef std::string(NMD:: *disassembly_function)(uint64 instruction,
-                                                     img_address m_pc);
-
     struct Pool {
         TABLE_ENTRY_TYPE     type;
         struct Pool          *next_table;
@@ -92,643 +91,6 @@ private:
                     TABLE_ENTRY_TYPE & type, const Pool *table,
                     int table_size, img_address m_pc);
 
-    std::string ABS_D(uint64 instruction, img_address m_pc);
-    std::string ABS_S(uint64 instruction, img_address m_pc);
-    std::string ABSQ_S_PH(uint64 instruction, img_address m_pc);
-    std::string ABSQ_S_QB(uint64 instruction, img_address m_pc);
-    std::string ABSQ_S_W(uint64 instruction, img_address m_pc);
-    std::string ACLR(uint64 instruction, img_address m_pc);
-    std::string ADD(uint64 instruction, img_address m_pc);
-    std::string ADD_D(uint64 instruction, img_address m_pc);
-    std::string ADD_S(uint64 instruction, img_address m_pc);
-    std::string ADDIU_32_(uint64 instruction, img_address m_pc);
-    std::string ADDIU_48_(uint64 instruction, img_address m_pc);
-    std::string ADDIU_GP48_(uint64 instruction, img_address m_pc);
-    std::string ADDIU_GP_B_(uint64 instruction, img_address m_pc);
-    std::string ADDIU_GP_W_(uint64 instruction, img_address m_pc);
-    std::string ADDIU_NEG_(uint64 instruction, img_address m_pc);
-    std::string ADDIU_R1_SP_(uint64 instruction, img_address m_pc);
-    std::string ADDIU_R2_(uint64 instruction, img_address m_pc);
-    std::string ADDIU_RS5_(uint64 instruction, img_address m_pc);
-    std::string ADDIUPC_32_(uint64 instruction, img_address m_pc);
-    std::string ADDIUPC_48_(uint64 instruction, img_address m_pc);
-    std::string ADDQ_PH(uint64 instruction, img_address m_pc);
-    std::string ADDQ_S_PH(uint64 instruction, img_address m_pc);
-    std::string ADDQ_S_W(uint64 instruction, img_address m_pc);
-    std::string ADDQH_PH(uint64 instruction, img_address m_pc);
-    std::string ADDQH_R_PH(uint64 instruction, img_address m_pc);
-    std::string ADDQH_R_W(uint64 instruction, img_address m_pc);
-    std::string ADDQH_W(uint64 instruction, img_address m_pc);
-    std::string ADDSC(uint64 instruction, img_address m_pc);
-    std::string ADDU_16_(uint64 instruction, img_address m_pc);
-    std::string ADDU_32_(uint64 instruction, img_address m_pc);
-    std::string ADDU_4X4_(uint64 instruction, img_address m_pc);
-    std::string ADDU_PH(uint64 instruction, img_address m_pc);
-    std::string ADDU_QB(uint64 instruction, img_address m_pc);
-    std::string ADDU_S_PH(uint64 instruction, img_address m_pc);
-    std::string ADDU_S_QB(uint64 instruction, img_address m_pc);
-    std::string ADDUH_QB(uint64 instruction, img_address m_pc);
-    std::string ADDUH_R_QB(uint64 instruction, img_address m_pc);
-    std::string ADDWC(uint64 instruction, img_address m_pc);
-    std::string ALUIPC(uint64 instruction, img_address m_pc);
-    std::string AND_16_(uint64 instruction, img_address m_pc);
-    std::string AND_32_(uint64 instruction, img_address m_pc);
-    std::string ANDI_16_(uint64 instruction, img_address m_pc);
-    std::string ANDI_32_(uint64 instruction, img_address m_pc);
-    std::string APPEND(uint64 instruction, img_address m_pc);
-    std::string ASET(uint64 instruction, img_address m_pc);
-    std::string BALC_16_(uint64 instruction, img_address m_pc);
-    std::string BALC_32_(uint64 instruction, img_address m_pc);
-    std::string BALRSC(uint64 instruction, img_address m_pc);
-    std::string BBEQZC(uint64 instruction, img_address m_pc);
-    std::string BBNEZC(uint64 instruction, img_address m_pc);
-    std::string BC_16_(uint64 instruction, img_address m_pc);
-    std::string BC_32_(uint64 instruction, img_address m_pc);
-    std::string BC1EQZC(uint64 instruction, img_address m_pc);
-    std::string BC1NEZC(uint64 instruction, img_address m_pc);
-    std::string BC2EQZC(uint64 instruction, img_address m_pc);
-    std::string BC2NEZC(uint64 instruction, img_address m_pc);
-    std::string BEQC_16_(uint64 instruction, img_address m_pc);
-    std::string BEQC_32_(uint64 instruction, img_address m_pc);
-    std::string BEQIC(uint64 instruction, img_address m_pc);
-    std::string BEQZC_16_(uint64 instruction, img_address m_pc);
-    std::string BGEC(uint64 instruction, img_address m_pc);
-    std::string BGEIC(uint64 instruction, img_address m_pc);
-    std::string BGEIUC(uint64 instruction, img_address m_pc);
-    std::string BGEUC(uint64 instruction, img_address m_pc);
-    std::string BLTC(uint64 instruction, img_address m_pc);
-    std::string BLTIC(uint64 instruction, img_address m_pc);
-    std::string BLTIUC(uint64 instruction, img_address m_pc);
-    std::string BLTUC(uint64 instruction, img_address m_pc);
-    std::string BNEC_16_(uint64 instruction, img_address m_pc);
-    std::string BNEC_32_(uint64 instruction, img_address m_pc);
-    std::string BNEIC(uint64 instruction, img_address m_pc);
-    std::string BNEZC_16_(uint64 instruction, img_address m_pc);
-    std::string BPOSGE32C(uint64 instruction, img_address m_pc);
-    std::string BREAK_16_(uint64 instruction, img_address m_pc);
-    std::string BREAK_32_(uint64 instruction, img_address m_pc);
-    std::string BRSC(uint64 instruction, img_address m_pc);
-    std::string CACHE(uint64 instruction, img_address m_pc);
-    std::string CACHEE(uint64 instruction, img_address m_pc);
-    std::string CEIL_L_D(uint64 instruction, img_address m_pc);
-    std::string CEIL_L_S(uint64 instruction, img_address m_pc);
-    std::string CEIL_W_D(uint64 instruction, img_address m_pc);
-    std::string CEIL_W_S(uint64 instruction, img_address m_pc);
-    std::string CFC1(uint64 instruction, img_address m_pc);
-    std::string CFC2(uint64 instruction, img_address m_pc);
-    std::string CLASS_D(uint64 instruction, img_address m_pc);
-    std::string CLASS_S(uint64 instruction, img_address m_pc);
-    std::string CLO(uint64 instruction, img_address m_pc);
-    std::string CLZ(uint64 instruction, img_address m_pc);
-    std::string CMP_AF_D(uint64 instruction, img_address m_pc);
-    std::string CMP_AF_S(uint64 instruction, img_address m_pc);
-    std::string CMP_EQ_D(uint64 instruction, img_address m_pc);
-    std::string CMP_EQ_PH(uint64 instruction, img_address m_pc);
-    std::string CMP_EQ_S(uint64 instruction, img_address m_pc);
-    std::string CMP_LE_D(uint64 instruction, img_address m_pc);
-    std::string CMP_LE_PH(uint64 instruction, img_address m_pc);
-    std::string CMP_LE_S(uint64 instruction, img_address m_pc);
-    std::string CMP_LT_D(uint64 instruction, img_address m_pc);
-    std::string CMP_LT_PH(uint64 instruction, img_address m_pc);
-    std::string CMP_LT_S(uint64 instruction, img_address m_pc);
-    std::string CMP_NE_D(uint64 instruction, img_address m_pc);
-    std::string CMP_NE_S(uint64 instruction, img_address m_pc);
-    std::string CMP_OR_D(uint64 instruction, img_address m_pc);
-    std::string CMP_OR_S(uint64 instruction, img_address m_pc);
-    std::string CMP_SAF_D(uint64 instruction, img_address m_pc);
-    std::string CMP_SAF_S(uint64 instruction, img_address m_pc);
-    std::string CMP_SEQ_D(uint64 instruction, img_address m_pc);
-    std::string CMP_SEQ_S(uint64 instruction, img_address m_pc);
-    std::string CMP_SLE_D(uint64 instruction, img_address m_pc);
-    std::string CMP_SLE_S(uint64 instruction, img_address m_pc);
-    std::string CMP_SLT_D(uint64 instruction, img_address m_pc);
-    std::string CMP_SLT_S(uint64 instruction, img_address m_pc);
-    std::string CMP_SNE_D(uint64 instruction, img_address m_pc);
-    std::string CMP_SNE_S(uint64 instruction, img_address m_pc);
-    std::string CMP_SOR_D(uint64 instruction, img_address m_pc);
-    std::string CMP_SOR_S(uint64 instruction, img_address m_pc);
-    std::string CMP_SUEQ_D(uint64 instruction, img_address m_pc);
-    std::string CMP_SUEQ_S(uint64 instruction, img_address m_pc);
-    std::string CMP_SULE_D(uint64 instruction, img_address m_pc);
-    std::string CMP_SULE_S(uint64 instruction, img_address m_pc);
-    std::string CMP_SULT_D(uint64 instruction, img_address m_pc);
-    std::string CMP_SULT_S(uint64 instruction, img_address m_pc);
-    std::string CMP_SUN_D(uint64 instruction, img_address m_pc);
-    std::string CMP_SUN_S(uint64 instruction, img_address m_pc);
-    std::string CMP_SUNE_D(uint64 instruction, img_address m_pc);
-    std::string CMP_SUNE_S(uint64 instruction, img_address m_pc);
-    std::string CMP_UEQ_D(uint64 instruction, img_address m_pc);
-    std::string CMP_UEQ_S(uint64 instruction, img_address m_pc);
-    std::string CMP_ULE_D(uint64 instruction, img_address m_pc);
-    std::string CMP_ULE_S(uint64 instruction, img_address m_pc);
-    std::string CMP_ULT_D(uint64 instruction, img_address m_pc);
-    std::string CMP_ULT_S(uint64 instruction, img_address m_pc);
-    std::string CMP_UN_D(uint64 instruction, img_address m_pc);
-    std::string CMP_UN_S(uint64 instruction, img_address m_pc);
-    std::string CMP_UNE_D(uint64 instruction, img_address m_pc);
-    std::string CMP_UNE_S(uint64 instruction, img_address m_pc);
-    std::string CMPGDU_EQ_QB(uint64 instruction, img_address m_pc);
-    std::string CMPGDU_LE_QB(uint64 instruction, img_address m_pc);
-    std::string CMPGDU_LT_QB(uint64 instruction, img_address m_pc);
-    std::string CMPGU_EQ_QB(uint64 instruction, img_address m_pc);
-    std::string CMPGU_LE_QB(uint64 instruction, img_address m_pc);
-    std::string CMPGU_LT_QB(uint64 instruction, img_address m_pc);
-    std::string CMPU_EQ_QB(uint64 instruction, img_address m_pc);
-    std::string CMPU_LE_QB(uint64 instruction, img_address m_pc);
-    std::string CMPU_LT_QB(uint64 instruction, img_address m_pc);
-    std::string COP2_1(uint64 instruction, img_address m_pc);
-    std::string CTC1(uint64 instruction, img_address m_pc);
-    std::string CTC2(uint64 instruction, img_address m_pc);
-    std::string CVT_D_L(uint64 instruction, img_address m_pc);
-    std::string CVT_D_S(uint64 instruction, img_address m_pc);
-    std::string CVT_D_W(uint64 instruction, img_address m_pc);
-    std::string CVT_L_D(uint64 instruction, img_address m_pc);
-    std::string CVT_L_S(uint64 instruction, img_address m_pc);
-    std::string CVT_S_D(uint64 instruction, img_address m_pc);
-    std::string CVT_S_L(uint64 instruction, img_address m_pc);
-    std::string CVT_S_PL(uint64 instruction, img_address m_pc);
-    std::string CVT_S_PU(uint64 instruction, img_address m_pc);
-    std::string CVT_S_W(uint64 instruction, img_address m_pc);
-    std::string CVT_W_D(uint64 instruction, img_address m_pc);
-    std::string CVT_W_S(uint64 instruction, img_address m_pc);
-    std::string DADDIU_48_(uint64 instruction, img_address m_pc);
-    std::string DADDIU_NEG_(uint64 instruction, img_address m_pc);
-    std::string DADDIU_U12_(uint64 instruction, img_address m_pc);
-    std::string DADD(uint64 instruction, img_address m_pc);
-    std::string DADDU(uint64 instruction, img_address m_pc);
-    std::string DCLO(uint64 instruction, img_address m_pc);
-    std::string DCLZ(uint64 instruction, img_address m_pc);
-    std::string DDIV(uint64 instruction, img_address m_pc);
-    std::string DDIVU(uint64 instruction, img_address m_pc);
-    std::string DERET(uint64 instruction, img_address m_pc);
-    std::string DEXTM(uint64 instruction, img_address m_pc);
-    std::string DEXT(uint64 instruction, img_address m_pc);
-    std::string DEXTU(uint64 instruction, img_address m_pc);
-    std::string DINSM(uint64 instruction, img_address m_pc);
-    std::string DINS(uint64 instruction, img_address m_pc);
-    std::string DINSU(uint64 instruction, img_address m_pc);
-    std::string DI(uint64 instruction, img_address m_pc);
-    std::string DIV(uint64 instruction, img_address m_pc);
-    std::string DIV_D(uint64 instruction, img_address m_pc);
-    std::string DIV_S(uint64 instruction, img_address m_pc);
-    std::string DIVU(uint64 instruction, img_address m_pc);
-    std::string DLSA(uint64 instruction, img_address m_pc);
-    std::string DLUI_48_(uint64 instruction, img_address m_pc);
-    std::string DMFC0(uint64 instruction, img_address m_pc);
-    std::string DMFC1(uint64 instruction, img_address m_pc);
-    std::string DMFC2(uint64 instruction, img_address m_pc);
-    std::string DMFGC0(uint64 instruction, img_address m_pc);
-    std::string DMOD(uint64 instruction, img_address m_pc);
-    std::string DMODU(uint64 instruction, img_address m_pc);
-    std::string DMTC0(uint64 instruction, img_address m_pc);
-    std::string DMTC1(uint64 instruction, img_address m_pc);
-    std::string DMTC2(uint64 instruction, img_address m_pc);
-    std::string DMTGC0(uint64 instruction, img_address m_pc);
-    std::string DMT(uint64 instruction, img_address m_pc);
-    std::string DMUH(uint64 instruction, img_address m_pc);
-    std::string DMUHU(uint64 instruction, img_address m_pc);
-    std::string DMUL(uint64 instruction, img_address m_pc);
-    std::string DMULU(uint64 instruction, img_address m_pc);
-    std::string DPAQ_S_W_PH(uint64 instruction, img_address m_pc);
-    std::string DPAQ_SA_L_W(uint64 instruction, img_address m_pc);
-    std::string DPAQX_S_W_PH(uint64 instruction, img_address m_pc);
-    std::string DPAQX_SA_W_PH(uint64 instruction, img_address m_pc);
-    std::string DPAU_H_QBL(uint64 instruction, img_address m_pc);
-    std::string DPAU_H_QBR(uint64 instruction, img_address m_pc);
-    std::string DPA_W_PH(uint64 instruction, img_address m_pc);
-    std::string DPAX_W_PH(uint64 instruction, img_address m_pc);
-    std::string DPS_W_PH(uint64 instruction, img_address m_pc);
-    std::string DPSQ_SA_L_W(uint64 instruction, img_address m_pc);
-    std::string DPSQ_S_W_PH(uint64 instruction, img_address m_pc);
-    std::string DPSQX_SA_W_PH(uint64 instruction, img_address m_pc);
-    std::string DPSQX_S_W_PH(uint64 instruction, img_address m_pc);
-    std::string DPSU_H_QBL(uint64 instruction, img_address m_pc);
-    std::string DPSU_H_QBR(uint64 instruction, img_address m_pc);
-    std::string DPSX_W_PH(uint64 instruction, img_address m_pc);
-    std::string DROTR(uint64 instruction, img_address m_pc);
-    std::string DROTR32(uint64 instruction, img_address m_pc);
-    std::string DROTRV(uint64 instruction, img_address m_pc);
-    std::string DROTX(uint64 instruction, img_address m_pc);
-    std::string DSLL(uint64 instruction, img_address m_pc);
-    std::string DSLL32(uint64 instruction, img_address m_pc);
-    std::string DSLLV(uint64 instruction, img_address m_pc);
-    std::string DSRA(uint64 instruction, img_address m_pc);
-    std::string DSRA32(uint64 instruction, img_address m_pc);
-    std::string DSRAV(uint64 instruction, img_address m_pc);
-    std::string DSRL32(uint64 instruction, img_address m_pc);
-    std::string DSRL(uint64 instruction, img_address m_pc);
-    std::string DSRLV(uint64 instruction, img_address m_pc);
-    std::string DSUB(uint64 instruction, img_address m_pc);
-    std::string DSUBU(uint64 instruction, img_address m_pc);
-    std::string DVP(uint64 instruction, img_address m_pc);
-    std::string DVPE(uint64 instruction, img_address m_pc);
-    std::string EHB(uint64 instruction, img_address m_pc);
-    std::string EI(uint64 instruction, img_address m_pc);
-    std::string EMT(uint64 instruction, img_address m_pc);
-    std::string ERET(uint64 instruction, img_address m_pc);
-    std::string ERETNC(uint64 instruction, img_address m_pc);
-    std::string EVP(uint64 instruction, img_address m_pc);
-    std::string EVPE(uint64 instruction, img_address m_pc);
-    std::string EXT(uint64 instruction, img_address m_pc);
-    std::string EXTD(uint64 instruction, img_address m_pc);
-    std::string EXTD32(uint64 instruction, img_address m_pc);
-    std::string EXTP(uint64 instruction, img_address m_pc);
-    std::string EXTPDP(uint64 instruction, img_address m_pc);
-    std::string EXTPDPV(uint64 instruction, img_address m_pc);
-    std::string EXTPV(uint64 instruction, img_address m_pc);
-    std::string EXTR_RS_W(uint64 instruction, img_address m_pc);
-    std::string EXTR_R_W(uint64 instruction, img_address m_pc);
-    std::string EXTR_S_H(uint64 instruction, img_address m_pc);
-    std::string EXTR_W(uint64 instruction, img_address m_pc);
-    std::string EXTRV_R_W(uint64 instruction, img_address m_pc);
-    std::string EXTRV_RS_W(uint64 instruction, img_address m_pc);
-    std::string EXTRV_S_H(uint64 instruction, img_address m_pc);
-    std::string EXTRV_W(uint64 instruction, img_address m_pc);
-    std::string EXTW(uint64 instruction, img_address m_pc);
-    std::string FLOOR_L_D(uint64 instruction, img_address m_pc);
-    std::string FLOOR_L_S(uint64 instruction, img_address m_pc);
-    std::string FLOOR_W_D(uint64 instruction, img_address m_pc);
-    std::string FLOOR_W_S(uint64 instruction, img_address m_pc);
-    std::string FORK(uint64 instruction, img_address m_pc);
-    std::string HYPCALL(uint64 instruction, img_address m_pc);
-    std::string HYPCALL_16_(uint64 instruction, img_address m_pc);
-    std::string INS(uint64 instruction, img_address m_pc);
-    std::string INSV(uint64 instruction, img_address m_pc);
-    std::string IRET(uint64 instruction, img_address m_pc);
-    std::string JALRC_16_(uint64 instruction, img_address m_pc);
-    std::string JALRC_32_(uint64 instruction, img_address m_pc);
-    std::string JALRC_HB(uint64 instruction, img_address m_pc);
-    std::string JRC(uint64 instruction, img_address m_pc);
-    std::string LB_16_(uint64 instruction, img_address m_pc);
-    std::string LB_GP_(uint64 instruction, img_address m_pc);
-    std::string LB_S9_(uint64 instruction, img_address m_pc);
-    std::string LB_U12_(uint64 instruction, img_address m_pc);
-    std::string LBE(uint64 instruction, img_address m_pc);
-    std::string LBU_16_(uint64 instruction, img_address m_pc);
-    std::string LBU_GP_(uint64 instruction, img_address m_pc);
-    std::string LBU_S9_(uint64 instruction, img_address m_pc);
-    std::string LBU_U12_(uint64 instruction, img_address m_pc);
-    std::string LBUE(uint64 instruction, img_address m_pc);
-    std::string LBUX(uint64 instruction, img_address m_pc);
-    std::string LBX(uint64 instruction, img_address m_pc);
-    std::string LD_GP_(uint64 instruction, img_address m_pc);
-    std::string LD_S9_(uint64 instruction, img_address m_pc);
-    std::string LD_U12_(uint64 instruction, img_address m_pc);
-    std::string LDC1_GP_(uint64 instruction, img_address m_pc);
-    std::string LDC1_S9_(uint64 instruction, img_address m_pc);
-    std::string LDC1_U12_(uint64 instruction, img_address m_pc);
-    std::string LDC1X(uint64 instruction, img_address m_pc);
-    std::string LDC1XS(uint64 instruction, img_address m_pc);
-    std::string LDC2(uint64 instruction, img_address m_pc);
-    std::string LDM(uint64 instruction, img_address m_pc);
-    std::string LDPC_48_(uint64 instruction, img_address m_pc);
-    std::string LDX(uint64 instruction, img_address m_pc);
-    std::string LDXS(uint64 instruction, img_address m_pc);
-    std::string LH_16_(uint64 instruction, img_address m_pc);
-    std::string LH_GP_(uint64 instruction, img_address m_pc);
-    std::string LH_S9_(uint64 instruction, img_address m_pc);
-    std::string LH_U12_(uint64 instruction, img_address m_pc);
-    std::string LHE(uint64 instruction, img_address m_pc);
-    std::string LHU_16_(uint64 instruction, img_address m_pc);
-    std::string LHU_GP_(uint64 instruction, img_address m_pc);
-    std::string LHU_S9_(uint64 instruction, img_address m_pc);
-    std::string LHU_U12_(uint64 instruction, img_address m_pc);
-    std::string LHUE(uint64 instruction, img_address m_pc);
-    std::string LHUX(uint64 instruction, img_address m_pc);
-    std::string LHUXS(uint64 instruction, img_address m_pc);
-    std::string LHX(uint64 instruction, img_address m_pc);
-    std::string LHXS(uint64 instruction, img_address m_pc);
-    std::string LI_16_(uint64 instruction, img_address m_pc);
-    std::string LI_48_(uint64 instruction, img_address m_pc);
-    std::string LL(uint64 instruction, img_address m_pc);
-    std::string LLD(uint64 instruction, img_address m_pc);
-    std::string LLDP(uint64 instruction, img_address m_pc);
-    std::string LLE(uint64 instruction, img_address m_pc);
-    std::string LLWP(uint64 instruction, img_address m_pc);
-    std::string LLWPE(uint64 instruction, img_address m_pc);
-    std::string LSA(uint64 instruction, img_address m_pc);
-    std::string LUI(uint64 instruction, img_address m_pc);
-    std::string LW_16_(uint64 instruction, img_address m_pc);
-    std::string LW_4X4_(uint64 instruction, img_address m_pc);
-    std::string LWC1_GP_(uint64 instruction, img_address m_pc);
-    std::string LWC1_S9_(uint64 instruction, img_address m_pc);
-    std::string LWC1_U12_(uint64 instruction, img_address m_pc);
-    std::string LWC1X(uint64 instruction, img_address m_pc);
-    std::string LWC1XS(uint64 instruction, img_address m_pc);
-    std::string LWC2(uint64 instruction, img_address m_pc);
-    std::string LWE(uint64 instruction, img_address m_pc);
-    std::string LW_GP_(uint64 instruction, img_address m_pc);
-    std::string LW_GP16_(uint64 instruction, img_address m_pc);
-    std::string LWM(uint64 instruction, img_address m_pc);
-    std::string LWPC_48_(uint64 instruction, img_address m_pc);
-    std::string LW_S9_(uint64 instruction, img_address m_pc);
-    std::string LW_SP_(uint64 instruction, img_address m_pc);
-    std::string LW_U12_(uint64 instruction, img_address m_pc);
-    std::string LWU_GP_(uint64 instruction, img_address m_pc);
-    std::string LWU_S9_(uint64 instruction, img_address m_pc);
-    std::string LWU_U12_(uint64 instruction, img_address m_pc);
-    std::string LWUX(uint64 instruction, img_address m_pc);
-    std::string LWUXS(uint64 instruction, img_address m_pc);
-    std::string LWX(uint64 instruction, img_address m_pc);
-    std::string LWXS_16_(uint64 instruction, img_address m_pc);
-    std::string LWXS_32_(uint64 instruction, img_address m_pc);
-    std::string MADD_DSP_(uint64 instruction, img_address m_pc);
-    std::string MADDF_D(uint64 instruction, img_address m_pc);
-    std::string MADDF_S(uint64 instruction, img_address m_pc);
-    std::string MADDU_DSP_(uint64 instruction, img_address m_pc);
-    std::string MAQ_S_W_PHL(uint64 instruction, img_address m_pc);
-    std::string MAQ_S_W_PHR(uint64 instruction, img_address m_pc);
-    std::string MAQ_SA_W_PHL(uint64 instruction, img_address m_pc);
-    std::string MAQ_SA_W_PHR(uint64 instruction, img_address m_pc);
-    std::string MAX_D(uint64 instruction, img_address m_pc);
-    std::string MAX_S(uint64 instruction, img_address m_pc);
-    std::string MAXA_D(uint64 instruction, img_address m_pc);
-    std::string MAXA_S(uint64 instruction, img_address m_pc);
-    std::string MFC0(uint64 instruction, img_address m_pc);
-    std::string MFC1(uint64 instruction, img_address m_pc);
-    std::string MFC2(uint64 instruction, img_address m_pc);
-    std::string MFGC0(uint64 instruction, img_address m_pc);
-    std::string MFHC0(uint64 instruction, img_address m_pc);
-    std::string MFHC1(uint64 instruction, img_address m_pc);
-    std::string MFHC2(uint64 instruction, img_address m_pc);
-    std::string MFHGC0(uint64 instruction, img_address m_pc);
-    std::string MFHI_DSP_(uint64 instruction, img_address m_pc);
-    std::string MFHTR(uint64 instruction, img_address m_pc);
-    std::string MFLO_DSP_(uint64 instruction, img_address m_pc);
-    std::string MFTR(uint64 instruction, img_address m_pc);
-    std::string MIN_D(uint64 instruction, img_address m_pc);
-    std::string MIN_S(uint64 instruction, img_address m_pc);
-    std::string MINA_D(uint64 instruction, img_address m_pc);
-    std::string MINA_S(uint64 instruction, img_address m_pc);
-    std::string MOD(uint64 instruction, img_address m_pc);
-    std::string MODSUB(uint64 instruction, img_address m_pc);
-    std::string MODU(uint64 instruction, img_address m_pc);
-    std::string MOV_D(uint64 instruction, img_address m_pc);
-    std::string MOV_S(uint64 instruction, img_address m_pc);
-    std::string MOVE_BALC(uint64 instruction, img_address m_pc);
-    std::string MOVEP(uint64 instruction, img_address m_pc);
-    std::string MOVEP_REV_(uint64 instruction, img_address m_pc);
-    std::string MOVE(uint64 instruction, img_address m_pc);
-    std::string MOVN(uint64 instruction, img_address m_pc);
-    std::string MOVZ(uint64 instruction, img_address m_pc);
-    std::string MSUB_DSP_(uint64 instruction, img_address m_pc);
-    std::string MSUBF_D(uint64 instruction, img_address m_pc);
-    std::string MSUBF_S(uint64 instruction, img_address m_pc);
-    std::string MSUBU_DSP_(uint64 instruction, img_address m_pc);
-    std::string MTC0(uint64 instruction, img_address m_pc);
-    std::string MTC1(uint64 instruction, img_address m_pc);
-    std::string MTC2(uint64 instruction, img_address m_pc);
-    std::string MTGC0(uint64 instruction, img_address m_pc);
-    std::string MTHC0(uint64 instruction, img_address m_pc);
-    std::string MTHC1(uint64 instruction, img_address m_pc);
-    std::string MTHC2(uint64 instruction, img_address m_pc);
-    std::string MTHGC0(uint64 instruction, img_address m_pc);
-    std::string MTHI_DSP_(uint64 instruction, img_address m_pc);
-    std::string MTHLIP(uint64 instruction, img_address m_pc);
-    std::string MTHTR(uint64 instruction, img_address m_pc);
-    std::string MTLO_DSP_(uint64 instruction, img_address m_pc);
-    std::string MTTR(uint64 instruction, img_address m_pc);
-    std::string MUH(uint64 instruction, img_address m_pc);
-    std::string MUHU(uint64 instruction, img_address m_pc);
-    std::string MUL_32_(uint64 instruction, img_address m_pc);
-    std::string MUL_4X4_(uint64 instruction, img_address m_pc);
-    std::string MUL_D(uint64 instruction, img_address m_pc);
-    std::string MUL_PH(uint64 instruction, img_address m_pc);
-    std::string MUL_S(uint64 instruction, img_address m_pc);
-    std::string MUL_S_PH(uint64 instruction, img_address m_pc);
-    std::string MULEQ_S_W_PHL(uint64 instruction, img_address m_pc);
-    std::string MULEQ_S_W_PHR(uint64 instruction, img_address m_pc);
-    std::string MULEU_S_PH_QBL(uint64 instruction, img_address m_pc);
-    std::string MULEU_S_PH_QBR(uint64 instruction, img_address m_pc);
-    std::string MULQ_RS_PH(uint64 instruction, img_address m_pc);
-    std::string MULQ_RS_W(uint64 instruction, img_address m_pc);
-    std::string MULQ_S_PH(uint64 instruction, img_address m_pc);
-    std::string MULQ_S_W(uint64 instruction, img_address m_pc);
-    std::string MULSA_W_PH(uint64 instruction, img_address m_pc);
-    std::string MULSAQ_S_W_PH(uint64 instruction, img_address m_pc);
-    std::string MULT_DSP_(uint64 instruction, img_address m_pc);
-    std::string MULTU_DSP_(uint64 instruction, img_address m_pc);
-    std::string MULU(uint64 instruction, img_address m_pc);
-    std::string NEG_D(uint64 instruction, img_address m_pc);
-    std::string NEG_S(uint64 instruction, img_address m_pc);
-    std::string NOP_16_(uint64 instruction, img_address m_pc);
-    std::string NOP_32_(uint64 instruction, img_address m_pc);
-    std::string NOR(uint64 instruction, img_address m_pc);
-    std::string NOT_16_(uint64 instruction, img_address m_pc);
-    std::string OR_16_(uint64 instruction, img_address m_pc);
-    std::string OR_32_(uint64 instruction, img_address m_pc);
-    std::string ORI(uint64 instruction, img_address m_pc);
-    std::string PACKRL_PH(uint64 instruction, img_address m_pc);
-    std::string PAUSE(uint64 instruction, img_address m_pc);
-    std::string PICK_PH(uint64 instruction, img_address m_pc);
-    std::string PICK_QB(uint64 instruction, img_address m_pc);
-    std::string PRECEQ_W_PHL(uint64 instruction, img_address m_pc);
-    std::string PRECEQ_W_PHR(uint64 instruction, img_address m_pc);
-    std::string PRECEQU_PH_QBL(uint64 instruction, img_address m_pc);
-    std::string PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc);
-    std::string PRECEQU_PH_QBR(uint64 instruction, img_address m_pc);
-    std::string PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc);
-    std::string PRECEU_PH_QBL(uint64 instruction, img_address m_pc);
-    std::string PRECEU_PH_QBLA(uint64 instruction, img_address m_pc);
-    std::string PRECEU_PH_QBR(uint64 instruction, img_address m_pc);
-    std::string PRECEU_PH_QBRA(uint64 instruction, img_address m_pc);
-    std::string PRECR_QB_PH(uint64 instruction, img_address m_pc);
-    std::string PRECR_SRA_PH_W(uint64 instruction, img_address m_pc);
-    std::string PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc);
-    std::string PRECRQ_PH_W(uint64 instruction, img_address m_pc);
-    std::string PRECRQ_QB_PH(uint64 instruction, img_address m_pc);
-    std::string PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc);
-    std::string PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc);
-    std::string PREF_S9_(uint64 instruction, img_address m_pc);
-    std::string PREF_U12_(uint64 instruction, img_address m_pc);
-    std::string PREFE(uint64 instruction, img_address m_pc);
-    std::string PREPEND(uint64 instruction, img_address m_pc);
-    std::string RADDU_W_QB(uint64 instruction, img_address m_pc);
-    std::string RDDSP(uint64 instruction, img_address m_pc);
-    std::string RDHWR(uint64 instruction, img_address m_pc);
-    std::string RDPGPR(uint64 instruction, img_address m_pc);
-    std::string RECIP_D(uint64 instruction, img_address m_pc);
-    std::string RECIP_S(uint64 instruction, img_address m_pc);
-    std::string REPL_PH(uint64 instruction, img_address m_pc);
-    std::string REPL_QB(uint64 instruction, img_address m_pc);
-    std::string REPLV_PH(uint64 instruction, img_address m_pc);
-    std::string REPLV_QB(uint64 instruction, img_address m_pc);
-    std::string RESTORE_32_(uint64 instruction, img_address m_pc);
-    std::string RESTORE_JRC_16_(uint64 instruction, img_address m_pc);
-    std::string RESTORE_JRC_32_(uint64 instruction, img_address m_pc);
-    std::string RESTOREF(uint64 instruction, img_address m_pc);
-    std::string RINT_D(uint64 instruction, img_address m_pc);
-    std::string RINT_S(uint64 instruction, img_address m_pc);
-    std::string ROTR(uint64 instruction, img_address m_pc);
-    std::string ROTRV(uint64 instruction, img_address m_pc);
-    std::string ROTX(uint64 instruction, img_address m_pc);
-    std::string ROUND_L_D(uint64 instruction, img_address m_pc);
-    std::string ROUND_L_S(uint64 instruction, img_address m_pc);
-    std::string ROUND_W_D(uint64 instruction, img_address m_pc);
-    std::string ROUND_W_S(uint64 instruction, img_address m_pc);
-    std::string RSQRT_D(uint64 instruction, img_address m_pc);
-    std::string RSQRT_S(uint64 instruction, img_address m_pc);
-    std::string SAVE_16_(uint64 instruction, img_address m_pc);
-    std::string SAVE_32_(uint64 instruction, img_address m_pc);
-    std::string SAVEF(uint64 instruction, img_address m_pc);
-    std::string SB_16_(uint64 instruction, img_address m_pc);
-    std::string SB_GP_(uint64 instruction, img_address m_pc);
-    std::string SB_S9_(uint64 instruction, img_address m_pc);
-    std::string SB_U12_(uint64 instruction, img_address m_pc);
-    std::string SBE(uint64 instruction, img_address m_pc);
-    std::string SBX(uint64 instruction, img_address m_pc);
-    std::string SC(uint64 instruction, img_address m_pc);
-    std::string SCD(uint64 instruction, img_address m_pc);
-    std::string SCDP(uint64 instruction, img_address m_pc);
-    std::string SCE(uint64 instruction, img_address m_pc);
-    std::string SCWP(uint64 instruction, img_address m_pc);
-    std::string SCWPE(uint64 instruction, img_address m_pc);
-    std::string SD_GP_(uint64 instruction, img_address m_pc);
-    std::string SD_S9_(uint64 instruction, img_address m_pc);
-    std::string SD_U12_(uint64 instruction, img_address m_pc);
-    std::string SDBBP_16_(uint64 instruction, img_address m_pc);
-    std::string SDBBP_32_(uint64 instruction, img_address m_pc);
-    std::string SDC1_GP_(uint64 instruction, img_address m_pc);
-    std::string SDC1_S9_(uint64 instruction, img_address m_pc);
-    std::string SDC1_U12_(uint64 instruction, img_address m_pc);
-    std::string SDC1X(uint64 instruction, img_address m_pc);
-    std::string SDC1XS(uint64 instruction, img_address m_pc);
-    std::string SDC2(uint64 instruction, img_address m_pc);
-    std::string SDM(uint64 instruction, img_address m_pc);
-    std::string SDPC_48_(uint64 instruction, img_address m_pc);
-    std::string SDX(uint64 instruction, img_address m_pc);
-    std::string SDXS(uint64 instruction, img_address m_pc);
-    std::string SEB(uint64 instruction, img_address m_pc);
-    std::string SEH(uint64 instruction, img_address m_pc);
-    std::string SEL_D(uint64 instruction, img_address m_pc);
-    std::string SEL_S(uint64 instruction, img_address m_pc);
-    std::string SELEQZ_D(uint64 instruction, img_address m_pc);
-    std::string SELEQZ_S(uint64 instruction, img_address m_pc);
-    std::string SELNEZ_D(uint64 instruction, img_address m_pc);
-    std::string SELNEZ_S(uint64 instruction, img_address m_pc);
-    std::string SEQI(uint64 instruction, img_address m_pc);
-    std::string SH_16_(uint64 instruction, img_address m_pc);
-    std::string SH_GP_(uint64 instruction, img_address m_pc);
-    std::string SH_S9_(uint64 instruction, img_address m_pc);
-    std::string SH_U12_(uint64 instruction, img_address m_pc);
-    std::string SHE(uint64 instruction, img_address m_pc);
-    std::string SHILO(uint64 instruction, img_address m_pc);
-    std::string SHILOV(uint64 instruction, img_address m_pc);
-    std::string SHLL_PH(uint64 instruction, img_address m_pc);
-    std::string SHLL_QB(uint64 instruction, img_address m_pc);
-    std::string SHLL_S_PH(uint64 instruction, img_address m_pc);
-    std::string SHLL_S_W(uint64 instruction, img_address m_pc);
-    std::string SHLLV_PH(uint64 instruction, img_address m_pc);
-    std::string SHLLV_QB(uint64 instruction, img_address m_pc);
-    std::string SHLLV_S_PH(uint64 instruction, img_address m_pc);
-    std::string SHLLV_S_W(uint64 instruction, img_address m_pc);
-    std::string SHRA_PH(uint64 instruction, img_address m_pc);
-    std::string SHRA_QB(uint64 instruction, img_address m_pc);
-    std::string SHRA_R_PH(uint64 instruction, img_address m_pc);
-    std::string SHRA_R_QB(uint64 instruction, img_address m_pc);
-    std::string SHRA_R_W(uint64 instruction, img_address m_pc);
-    std::string SHRAV_PH(uint64 instruction, img_address m_pc);
-    std::string SHRAV_QB(uint64 instruction, img_address m_pc);
-    std::string SHRAV_R_PH(uint64 instruction, img_address m_pc);
-    std::string SHRAV_R_QB(uint64 instruction, img_address m_pc);
-    std::string SHRAV_R_W(uint64 instruction, img_address m_pc);
-    std::string SHRL_PH(uint64 instruction, img_address m_pc);
-    std::string SHRL_QB(uint64 instruction, img_address m_pc);
-    std::string SHRLV_PH(uint64 instruction, img_address m_pc);
-    std::string SHRLV_QB(uint64 instruction, img_address m_pc);
-    std::string SHX(uint64 instruction, img_address m_pc);
-    std::string SHXS(uint64 instruction, img_address m_pc);
-    std::string SIGRIE(uint64 instruction, img_address m_pc);
-    std::string SLL_16_(uint64 instruction, img_address m_pc);
-    std::string SLL_32_(uint64 instruction, img_address m_pc);
-    std::string SLLV(uint64 instruction, img_address m_pc);
-    std::string SLT(uint64 instruction, img_address m_pc);
-    std::string SLTI(uint64 instruction, img_address m_pc);
-    std::string SLTIU(uint64 instruction, img_address m_pc);
-    std::string SLTU(uint64 instruction, img_address m_pc);
-    std::string SOV(uint64 instruction, img_address m_pc);
-    std::string SPECIAL2(uint64 instruction, img_address m_pc);
-    std::string SQRT_D(uint64 instruction, img_address m_pc);
-    std::string SQRT_S(uint64 instruction, img_address m_pc);
-    std::string SRA(uint64 instruction, img_address m_pc);
-    std::string SRAV(uint64 instruction, img_address m_pc);
-    std::string SRL_16_(uint64 instruction, img_address m_pc);
-    std::string SRL_32_(uint64 instruction, img_address m_pc);
-    std::string SRLV(uint64 instruction, img_address m_pc);
-    std::string SUB(uint64 instruction, img_address m_pc);
-    std::string SUB_D(uint64 instruction, img_address m_pc);
-    std::string SUB_S(uint64 instruction, img_address m_pc);
-    std::string SUBQ_PH(uint64 instruction, img_address m_pc);
-    std::string SUBQ_S_PH(uint64 instruction, img_address m_pc);
-    std::string SUBQ_S_W(uint64 instruction, img_address m_pc);
-    std::string SUBQH_PH(uint64 instruction, img_address m_pc);
-    std::string SUBQH_R_PH(uint64 instruction, img_address m_pc);
-    std::string SUBQH_R_W(uint64 instruction, img_address m_pc);
-    std::string SUBQH_W(uint64 instruction, img_address m_pc);
-    std::string SUBU_16_(uint64 instruction, img_address m_pc);
-    std::string SUBU_32_(uint64 instruction, img_address m_pc);
-    std::string SUBU_PH(uint64 instruction, img_address m_pc);
-    std::string SUBU_QB(uint64 instruction, img_address m_pc);
-    std::string SUBU_S_PH(uint64 instruction, img_address m_pc);
-    std::string SUBU_S_QB(uint64 instruction, img_address m_pc);
-    std::string SUBUH_QB(uint64 instruction, img_address m_pc);
-    std::string SUBUH_R_QB(uint64 instruction, img_address m_pc);
-    std::string SW_16_(uint64 instruction, img_address m_pc);
-    std::string SW_4X4_(uint64 instruction, img_address m_pc);
-    std::string SW_GP16_(uint64 instruction, img_address m_pc);
-    std::string SW_GP_(uint64 instruction, img_address m_pc);
-    std::string SW_S9_(uint64 instruction, img_address m_pc);
-    std::string SW_SP_(uint64 instruction, img_address m_pc);
-    std::string SW_U12_(uint64 instruction, img_address m_pc);
-    std::string SWC1_GP_(uint64 instruction, img_address m_pc);
-    std::string SWC1_S9_(uint64 instruction, img_address m_pc);
-    std::string SWC1_U12_(uint64 instruction, img_address m_pc);
-    std::string SWC1X(uint64 instruction, img_address m_pc);
-    std::string SWC1XS(uint64 instruction, img_address m_pc);
-    std::string SWC2(uint64 instruction, img_address m_pc);
-    std::string SWE(uint64 instruction, img_address m_pc);
-    std::string SWM(uint64 instruction, img_address m_pc);
-    std::string SWPC_48_(uint64 instruction, img_address m_pc);
-    std::string SWX(uint64 instruction, img_address m_pc);
-    std::string SWXS(uint64 instruction, img_address m_pc);
-    std::string SYNC(uint64 instruction, img_address m_pc);
-    std::string SYNCI(uint64 instruction, img_address m_pc);
-    std::string SYNCIE(uint64 instruction, img_address m_pc);
-    std::string SYSCALL_16_(uint64 instruction, img_address m_pc);
-    std::string SYSCALL_32_(uint64 instruction, img_address m_pc);
-    std::string TEQ(uint64 instruction, img_address m_pc);
-    std::string TLBGINV(uint64 instruction, img_address m_pc);
-    std::string TLBGINVF(uint64 instruction, img_address m_pc);
-    std::string TLBGP(uint64 instruction, img_address m_pc);
-    std::string TLBGR(uint64 instruction, img_address m_pc);
-    std::string TLBGWI(uint64 instruction, img_address m_pc);
-    std::string TLBGWR(uint64 instruction, img_address m_pc);
-    std::string TLBINV(uint64 instruction, img_address m_pc);
-    std::string TLBINVF(uint64 instruction, img_address m_pc);
-    std::string TLBP(uint64 instruction, img_address m_pc);
-    std::string TLBR(uint64 instruction, img_address m_pc);
-    std::string TLBWI(uint64 instruction, img_address m_pc);
-    std::string TLBWR(uint64 instruction, img_address m_pc);
-    std::string TNE(uint64 instruction, img_address m_pc);
-    std::string TRUNC_L_D(uint64 instruction, img_address m_pc);
-    std::string TRUNC_L_S(uint64 instruction, img_address m_pc);
-    std::string TRUNC_W_D(uint64 instruction, img_address m_pc);
-    std::string TRUNC_W_S(uint64 instruction, img_address m_pc);
-    std::string UALDM(uint64 instruction, img_address m_pc);
-    std::string UALH(uint64 instruction, img_address m_pc);
-    std::string UALWM(uint64 instruction, img_address m_pc);
-    std::string UASDM(uint64 instruction, img_address m_pc);
-    std::string UASH(uint64 instruction, img_address m_pc);
-    std::string UASWM(uint64 instruction, img_address m_pc);
-    std::string UDI(uint64 instruction, img_address m_pc);
-    std::string WAIT(uint64 instruction, img_address m_pc);
-    std::string WRDSP(uint64 instruction, img_address m_pc);
-    std::string WRPGPR(uint64 instruction, img_address m_pc);
-    std::string XOR_16_(uint64 instruction, img_address m_pc);
-    std::string XOR_32_(uint64 instruction, img_address m_pc);
-    std::string XORI(uint64 instruction, img_address m_pc);
-    std::string YIELD(uint64 instruction, img_address m_pc);
-
     static Pool P_SYSCALL[2];
     static Pool P_RI[4];
     static Pool P_ADDIU[2];
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 06/20] disas/nanomips: Remove disasm methods from class
  2022-09-05  9:55 ` [PATCH v2 06/20] disas/nanomips: Remove disasm " Milica Lazarevic
@ 2022-09-05 11:08   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:08 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic,
	Philippe Mathieu-Daudé

On 9/5/22 10:55, Milica Lazarevic wrote:
> NMD class methods with the disassembly_function type like
> NMD::ABS_D, NMD::ABS_S, etc. are removed from the class. They're now
> declared global static functions. Therefore, typedef of the function
> pointer, disassembly_function is defined outside of the class.
> 
> Now that disassembly_function type functions are not part of the NMD
> class we can't access them using the this pointer. Thus, the use of
> the this pointer has been deleted.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> Reviewed-by: Philippe Mathieu-Daudé<f4bug@amsat.org>
> ---
>   disas/nanomips.cpp | 2546 ++++++++++++++++++++++----------------------
>   disas/nanomips.h   |  642 +----------
>   2 files changed, 1275 insertions(+), 1913 deletions(-)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 07/20] disas/nanomips: Remove Pool tables from the class
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (5 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 06/20] disas/nanomips: Remove disasm " Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:11   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 08/20] disas/nanomips: Remove NMD class Milica Lazarevic
                   ` (12 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic, Philippe Mathieu-Daudé

Pool tables are no longer declared as static fields of the NMD
class but as global static variables.

The NMD::Disassemble method is using the MAJOR Pool table variable, so
its implementation is moved to the end of the nanomips.cpp file,
right after the initialization of the MAJOR Pool table.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
---
 disas/nanomips.cpp | 363 ++++++++++++++++++++++-----------------------
 disas/nanomips.h   | 200 ++-----------------------
 2 files changed, 193 insertions(+), 370 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index 7ea6326f1d..37809ff365 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -751,13 +751,6 @@ uint64 NMD::extract_op_code_value(const uint16 * data, int size)
 }
 
 
-int NMD::Disassemble(const uint16 * data, std::string & dis,
-                     TABLE_ENTRY_TYPE & type, img_address m_pc)
-{
-    return Disassemble(data, dis, type, MAJOR, 2, m_pc);
-}
-
-
 /*
  * Recurse through tables until the instruction is found then return
  * the string and size
@@ -16667,7 +16660,7 @@ static std::string YIELD(uint64 instruction, img_address m_pc)
  *
  */
 
-NMD::Pool NMD::P_SYSCALL[2] = {
+static struct Pool P_SYSCALL[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfffc0000, 0x00080000, &SYSCALL_32_      , 0,
        0x0                 },        /* SYSCALL[32] */
@@ -16677,7 +16670,7 @@ NMD::Pool NMD::P_SYSCALL[2] = {
 };
 
 
-NMD::Pool NMD::P_RI[4] = {
+static struct Pool P_RI[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfff80000, 0x00000000, &SIGRIE           , 0,
        0x0                 },        /* SIGRIE */
@@ -16693,7 +16686,7 @@ NMD::Pool NMD::P_RI[4] = {
 };
 
 
-NMD::Pool NMD::P_ADDIU[2] = {
+static struct Pool P_ADDIU[2] = {
     { pool                , P_RI                , 4   , 32,
        0xffe00000, 0x00000000, 0                      , 0,
        0x0                 },        /* P.RI */
@@ -16703,7 +16696,7 @@ NMD::Pool NMD::P_ADDIU[2] = {
 };
 
 
-NMD::Pool NMD::P_TRAP[2] = {
+static struct Pool P_TRAP[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x20000000, &TEQ              , 0,
        XMMS_               },        /* TEQ */
@@ -16713,7 +16706,7 @@ NMD::Pool NMD::P_TRAP[2] = {
 };
 
 
-NMD::Pool NMD::P_CMOVE[2] = {
+static struct Pool P_CMOVE[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x20000210, &MOVZ             , 0,
        0x0                 },        /* MOVZ */
@@ -16723,7 +16716,7 @@ NMD::Pool NMD::P_CMOVE[2] = {
 };
 
 
-NMD::Pool NMD::P_D_MT_VPE[2] = {
+static struct Pool P_D_MT_VPE[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc1f3fff, 0x20010ab0, &DMT              , 0,
        MT_                 },        /* DMT */
@@ -16733,7 +16726,7 @@ NMD::Pool NMD::P_D_MT_VPE[2] = {
 };
 
 
-NMD::Pool NMD::P_E_MT_VPE[2] = {
+static struct Pool P_E_MT_VPE[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc1f3fff, 0x20010eb0, &EMT              , 0,
        MT_                 },        /* EMT */
@@ -16743,7 +16736,7 @@ NMD::Pool NMD::P_E_MT_VPE[2] = {
 };
 
 
-NMD::Pool NMD::_P_MT_VPE[2] = {
+static struct Pool _P_MT_VPE[2] = {
     { pool                , P_D_MT_VPE          , 2   , 32,
        0xfc003fff, 0x20000ab0, 0                      , 0,
        0x0                 },        /* P.D_MT_VPE */
@@ -16753,7 +16746,7 @@ NMD::Pool NMD::_P_MT_VPE[2] = {
 };
 
 
-NMD::Pool NMD::P_MT_VPE[8] = {
+static struct Pool P_MT_VPE[8] = {
     { reserved_block      , 0                   , 0   , 32,
        0xfc003bff, 0x200002b0, 0                      , 0,
        0x0                 },        /* P.MT_VPE~*(0) */
@@ -16781,7 +16774,7 @@ NMD::Pool NMD::P_MT_VPE[8] = {
 };
 
 
-NMD::Pool NMD::P_DVP[2] = {
+static struct Pool P_DVP[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00ffff, 0x20000390, &DVP              , 0,
        0x0                 },        /* DVP */
@@ -16791,7 +16784,7 @@ NMD::Pool NMD::P_DVP[2] = {
 };
 
 
-NMD::Pool NMD::P_SLTU[2] = {
+static struct Pool P_SLTU[2] = {
     { pool                , P_DVP               , 2   , 32,
        0xfc00fbff, 0x20000390, 0                      , 0,
        0x0                 },        /* P.DVP */
@@ -16801,7 +16794,7 @@ NMD::Pool NMD::P_SLTU[2] = {
 };
 
 
-NMD::Pool NMD::_POOL32A0[128] = {
+static struct Pool _POOL32A0[128] = {
     { pool                , P_TRAP              , 2   , 32,
        0xfc0003ff, 0x20000000, 0                      , 0,
        0x0                 },        /* P.TRAP */
@@ -17189,7 +17182,7 @@ NMD::Pool NMD::_POOL32A0[128] = {
 };
 
 
-NMD::Pool NMD::ADDQ__S__PH[2] = {
+static struct Pool ADDQ__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000000d, &ADDQ_PH          , 0,
        DSP_                },        /* ADDQ.PH */
@@ -17199,7 +17192,7 @@ NMD::Pool NMD::ADDQ__S__PH[2] = {
 };
 
 
-NMD::Pool NMD::MUL__S__PH[2] = {
+static struct Pool MUL__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000002d, &MUL_PH           , 0,
        DSP_                },        /* MUL.PH */
@@ -17209,7 +17202,7 @@ NMD::Pool NMD::MUL__S__PH[2] = {
 };
 
 
-NMD::Pool NMD::ADDQH__R__PH[2] = {
+static struct Pool ADDQH__R__PH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000004d, &ADDQH_PH         , 0,
        DSP_                },        /* ADDQH.PH */
@@ -17219,7 +17212,7 @@ NMD::Pool NMD::ADDQH__R__PH[2] = {
 };
 
 
-NMD::Pool NMD::ADDQH__R__W[2] = {
+static struct Pool ADDQH__R__W[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000008d, &ADDQH_W          , 0,
        DSP_                },        /* ADDQH.W */
@@ -17229,7 +17222,7 @@ NMD::Pool NMD::ADDQH__R__W[2] = {
 };
 
 
-NMD::Pool NMD::ADDU__S__QB[2] = {
+static struct Pool ADDU__S__QB[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x200000cd, &ADDU_QB          , 0,
        DSP_                },        /* ADDU.QB */
@@ -17239,7 +17232,7 @@ NMD::Pool NMD::ADDU__S__QB[2] = {
 };
 
 
-NMD::Pool NMD::ADDU__S__PH[2] = {
+static struct Pool ADDU__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000010d, &ADDU_PH          , 0,
        DSP_                },        /* ADDU.PH */
@@ -17249,7 +17242,7 @@ NMD::Pool NMD::ADDU__S__PH[2] = {
 };
 
 
-NMD::Pool NMD::ADDUH__R__QB[2] = {
+static struct Pool ADDUH__R__QB[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000014d, &ADDUH_QB         , 0,
        DSP_                },        /* ADDUH.QB */
@@ -17259,7 +17252,7 @@ NMD::Pool NMD::ADDUH__R__QB[2] = {
 };
 
 
-NMD::Pool NMD::SHRAV__R__PH[2] = {
+static struct Pool SHRAV__R__PH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000018d, &SHRAV_PH         , 0,
        DSP_                },        /* SHRAV.PH */
@@ -17269,7 +17262,7 @@ NMD::Pool NMD::SHRAV__R__PH[2] = {
 };
 
 
-NMD::Pool NMD::SHRAV__R__QB[2] = {
+static struct Pool SHRAV__R__QB[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x200001cd, &SHRAV_QB         , 0,
        DSP_                },        /* SHRAV.QB */
@@ -17279,7 +17272,7 @@ NMD::Pool NMD::SHRAV__R__QB[2] = {
 };
 
 
-NMD::Pool NMD::SUBQ__S__PH[2] = {
+static struct Pool SUBQ__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000020d, &SUBQ_PH          , 0,
        DSP_                },        /* SUBQ.PH */
@@ -17289,7 +17282,7 @@ NMD::Pool NMD::SUBQ__S__PH[2] = {
 };
 
 
-NMD::Pool NMD::SUBQH__R__PH[2] = {
+static struct Pool SUBQH__R__PH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000024d, &SUBQH_PH         , 0,
        DSP_                },        /* SUBQH.PH */
@@ -17299,7 +17292,7 @@ NMD::Pool NMD::SUBQH__R__PH[2] = {
 };
 
 
-NMD::Pool NMD::SUBQH__R__W[2] = {
+static struct Pool SUBQH__R__W[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000028d, &SUBQH_W          , 0,
        DSP_                },        /* SUBQH.W */
@@ -17309,7 +17302,7 @@ NMD::Pool NMD::SUBQH__R__W[2] = {
 };
 
 
-NMD::Pool NMD::SUBU__S__QB[2] = {
+static struct Pool SUBU__S__QB[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x200002cd, &SUBU_QB          , 0,
        DSP_                },        /* SUBU.QB */
@@ -17319,7 +17312,7 @@ NMD::Pool NMD::SUBU__S__QB[2] = {
 };
 
 
-NMD::Pool NMD::SUBU__S__PH[2] = {
+static struct Pool SUBU__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000030d, &SUBU_PH          , 0,
        DSP_                },        /* SUBU.PH */
@@ -17329,7 +17322,7 @@ NMD::Pool NMD::SUBU__S__PH[2] = {
 };
 
 
-NMD::Pool NMD::SHRA__R__PH[2] = {
+static struct Pool SHRA__R__PH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x20000335, &SHRA_PH          , 0,
        DSP_                },        /* SHRA.PH */
@@ -17339,7 +17332,7 @@ NMD::Pool NMD::SHRA__R__PH[2] = {
 };
 
 
-NMD::Pool NMD::SUBUH__R__QB[2] = {
+static struct Pool SUBUH__R__QB[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000034d, &SUBUH_QB         , 0,
        DSP_                },        /* SUBUH.QB */
@@ -17349,7 +17342,7 @@ NMD::Pool NMD::SUBUH__R__QB[2] = {
 };
 
 
-NMD::Pool NMD::SHLLV__S__PH[2] = {
+static struct Pool SHLLV__S__PH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x2000038d, &SHLLV_PH         , 0,
        DSP_                },        /* SHLLV.PH */
@@ -17359,7 +17352,7 @@ NMD::Pool NMD::SHLLV__S__PH[2] = {
 };
 
 
-NMD::Pool NMD::SHLL__S__PH[4] = {
+static struct Pool SHLL__S__PH[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc000fff, 0x200003b5, &SHLL_PH          , 0,
        DSP_                },        /* SHLL.PH */
@@ -17375,7 +17368,7 @@ NMD::Pool NMD::SHLL__S__PH[4] = {
 };
 
 
-NMD::Pool NMD::PRECR_SRA__R__PH_W[2] = {
+static struct Pool PRECR_SRA__R__PH_W[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x200003cd, &PRECR_SRA_PH_W   , 0,
        DSP_                },        /* PRECR_SRA.PH.W */
@@ -17385,7 +17378,7 @@ NMD::Pool NMD::PRECR_SRA__R__PH_W[2] = {
 };
 
 
-NMD::Pool NMD::_POOL32A5[128] = {
+static struct Pool _POOL32A5[128] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0x20000005, &CMP_EQ_PH        , 0,
        DSP_                },        /* CMP.EQ.PH */
@@ -17773,7 +17766,7 @@ NMD::Pool NMD::_POOL32A5[128] = {
 };
 
 
-NMD::Pool NMD::PP_LSX[16] = {
+static struct Pool PP_LSX[16] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0x20000007, &LBX              , 0,
        0x0                 },        /* LBX */
@@ -17825,7 +17818,7 @@ NMD::Pool NMD::PP_LSX[16] = {
 };
 
 
-NMD::Pool NMD::PP_LSXS[16] = {
+static struct Pool PP_LSXS[16] = {
     { reserved_block      , 0                   , 0   , 32,
        0xfc0007ff, 0x20000047, 0                      , 0,
        0x0                 },        /* PP.LSXS~*(0) */
@@ -17877,7 +17870,7 @@ NMD::Pool NMD::PP_LSXS[16] = {
 };
 
 
-NMD::Pool NMD::P_LSX[2] = {
+static struct Pool P_LSX[2] = {
     { pool                , PP_LSX              , 16  , 32,
        0xfc00007f, 0x20000007, 0                      , 0,
        0x0                 },        /* PP.LSX */
@@ -17887,7 +17880,7 @@ NMD::Pool NMD::P_LSX[2] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_1_0[4] = {
+static struct Pool POOL32Axf_1_0[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc003fff, 0x2000007f, &MFHI_DSP_        , 0,
        DSP_                },        /* MFHI[DSP] */
@@ -17903,7 +17896,7 @@ NMD::Pool NMD::POOL32Axf_1_0[4] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_1_1[4] = {
+static struct Pool POOL32Axf_1_1[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc003fff, 0x2000027f, &MTHLIP           , 0,
        DSP_                },        /* MTHLIP */
@@ -17919,7 +17912,7 @@ NMD::Pool NMD::POOL32Axf_1_1[4] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_1_3[4] = {
+static struct Pool POOL32Axf_1_3[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc003fff, 0x2000067f, &RDDSP            , 0,
        DSP_                },        /* RDDSP */
@@ -17935,7 +17928,7 @@ NMD::Pool NMD::POOL32Axf_1_3[4] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_1_4[2] = {
+static struct Pool POOL32Axf_1_4[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc001fff, 0x2000087f, &SHLL_QB          , 0,
        DSP_                },        /* SHLL.QB */
@@ -17945,7 +17938,7 @@ NMD::Pool NMD::POOL32Axf_1_4[2] = {
 };
 
 
-NMD::Pool NMD::MAQ_S_A__W_PHR[2] = {
+static struct Pool MAQ_S_A__W_PHR[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc003fff, 0x20000a7f, &MAQ_S_W_PHR      , 0,
        DSP_                },        /* MAQ_S.W.PHR */
@@ -17955,7 +17948,7 @@ NMD::Pool NMD::MAQ_S_A__W_PHR[2] = {
 };
 
 
-NMD::Pool NMD::MAQ_S_A__W_PHL[2] = {
+static struct Pool MAQ_S_A__W_PHL[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc003fff, 0x20001a7f, &MAQ_S_W_PHL      , 0,
        DSP_                },        /* MAQ_S.W.PHL */
@@ -17965,7 +17958,7 @@ NMD::Pool NMD::MAQ_S_A__W_PHL[2] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_1_5[2] = {
+static struct Pool POOL32Axf_1_5[2] = {
     { pool                , MAQ_S_A__W_PHR      , 2   , 32,
        0xfc001fff, 0x20000a7f, 0                      , 0,
        0x0                 },        /* MAQ_S[A].W.PHR */
@@ -17975,7 +17968,7 @@ NMD::Pool NMD::POOL32Axf_1_5[2] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_1_7[4] = {
+static struct Pool POOL32Axf_1_7[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc003fff, 0x20000e7f, &EXTR_W           , 0,
        DSP_                },        /* EXTR.W */
@@ -17991,7 +17984,7 @@ NMD::Pool NMD::POOL32Axf_1_7[4] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_1[8] = {
+static struct Pool POOL32Axf_1[8] = {
     { pool                , POOL32Axf_1_0       , 4   , 32,
        0xfc000fff, 0x2000007f, 0                      , 0,
        0x0                 },        /* POOL32Axf_1_0 */
@@ -18019,7 +18012,7 @@ NMD::Pool NMD::POOL32Axf_1[8] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_2_DSP__0_7[8] = {
+static struct Pool POOL32Axf_2_DSP__0_7[8] = {
     { instruction         , 0                   , 0   , 32,
        0xfc003fff, 0x200000bf, &DPA_W_PH         , 0,
        DSP_                },        /* DPA.W.PH */
@@ -18047,7 +18040,7 @@ NMD::Pool NMD::POOL32Axf_2_DSP__0_7[8] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_2_DSP__8_15[8] = {
+static struct Pool POOL32Axf_2_DSP__8_15[8] = {
     { instruction         , 0                   , 0   , 32,
        0xfc003fff, 0x200010bf, &DPAX_W_PH        , 0,
        DSP_                },        /* DPAX.W.PH */
@@ -18075,7 +18068,7 @@ NMD::Pool NMD::POOL32Axf_2_DSP__8_15[8] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_2_DSP__16_23[8] = {
+static struct Pool POOL32Axf_2_DSP__16_23[8] = {
     { instruction         , 0                   , 0   , 32,
        0xfc003fff, 0x200020bf, &DPAU_H_QBL       , 0,
        DSP_                },        /* DPAU.H.QBL */
@@ -18103,7 +18096,7 @@ NMD::Pool NMD::POOL32Axf_2_DSP__16_23[8] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_2_DSP__24_31[8] = {
+static struct Pool POOL32Axf_2_DSP__24_31[8] = {
     { instruction         , 0                   , 0   , 32,
        0xfc003fff, 0x200030bf, &DPAU_H_QBR       , 0,
        DSP_                },        /* DPAU.H.QBR */
@@ -18131,7 +18124,7 @@ NMD::Pool NMD::POOL32Axf_2_DSP__24_31[8] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_2[4] = {
+static struct Pool POOL32Axf_2[4] = {
     { pool                , POOL32Axf_2_DSP__0_7, 8   , 32,
        0xfc0031ff, 0x200000bf, 0                      , 0,
        0x0                 },        /* POOL32Axf_2(DSP)_0_7 */
@@ -18147,7 +18140,7 @@ NMD::Pool NMD::POOL32Axf_2[4] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_4[128] = {
+static struct Pool POOL32Axf_4[128] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00ffff, 0x2000013f, &ABSQ_S_QB        , 0,
        DSP_                },        /* ABSQ_S.QB */
@@ -18535,7 +18528,7 @@ NMD::Pool NMD::POOL32Axf_4[128] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_5_group0[32] = {
+static struct Pool POOL32Axf_5_group0[32] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00ffff, 0x2000017f, &TLBGP            , 0,
        CP0_ | VZ_ | TLB_   },        /* TLBGP */
@@ -18635,7 +18628,7 @@ NMD::Pool NMD::POOL32Axf_5_group0[32] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_5_group1[32] = {
+static struct Pool POOL32Axf_5_group1[32] = {
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000417f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group1~*(0) */
@@ -18735,7 +18728,7 @@ NMD::Pool NMD::POOL32Axf_5_group1[32] = {
 };
 
 
-NMD::Pool NMD::ERETx[2] = {
+static struct Pool ERETx[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc01ffff, 0x2000f37f, &ERET             , 0,
        0x0                 },        /* ERET */
@@ -18745,7 +18738,7 @@ NMD::Pool NMD::ERETx[2] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_5_group3[32] = {
+static struct Pool POOL32Axf_5_group3[32] = {
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0x2000c17f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group3~*(0) */
@@ -18845,7 +18838,7 @@ NMD::Pool NMD::POOL32Axf_5_group3[32] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_5[4] = {
+static struct Pool POOL32Axf_5[4] = {
     { pool                , POOL32Axf_5_group0  , 32  , 32,
        0xfc00c1ff, 0x2000017f, 0                      , 0,
        0x0                 },        /* POOL32Axf_5_group0 */
@@ -18861,7 +18854,7 @@ NMD::Pool NMD::POOL32Axf_5[4] = {
 };
 
 
-NMD::Pool NMD::SHRA__R__QB[2] = {
+static struct Pool SHRA__R__QB[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc001fff, 0x200001ff, &SHRA_QB          , 0,
        DSP_                },        /* SHRA.QB */
@@ -18871,7 +18864,7 @@ NMD::Pool NMD::SHRA__R__QB[2] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf_7[8] = {
+static struct Pool POOL32Axf_7[8] = {
     { pool                , SHRA__R__QB         , 2   , 32,
        0xfc000fff, 0x200001ff, 0                      , 0,
        0x0                 },        /* SHRA[_R].QB */
@@ -18899,7 +18892,7 @@ NMD::Pool NMD::POOL32Axf_7[8] = {
 };
 
 
-NMD::Pool NMD::POOL32Axf[8] = {
+static struct Pool POOL32Axf[8] = {
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0x2000003f, 0                      , 0,
        0x0                 },        /* POOL32Axf~*(0) */
@@ -18927,7 +18920,7 @@ NMD::Pool NMD::POOL32Axf[8] = {
 };
 
 
-NMD::Pool NMD::_POOL32A7[8] = {
+static struct Pool _POOL32A7[8] = {
     { pool                , P_LSX               , 2   , 32,
        0xfc00003f, 0x20000007, 0                      , 0,
        0x0                 },        /* P.LSX */
@@ -18955,7 +18948,7 @@ NMD::Pool NMD::_POOL32A7[8] = {
 };
 
 
-NMD::Pool NMD::P32A[8] = {
+static struct Pool P32A[8] = {
     { pool                , _POOL32A0           , 128 , 32,
        0xfc000007, 0x20000000, 0                      , 0,
        0x0                 },        /* _POOL32A0 */
@@ -18983,7 +18976,7 @@ NMD::Pool NMD::P32A[8] = {
 };
 
 
-NMD::Pool NMD::P_GP_D[2] = {
+static struct Pool P_GP_D[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc000007, 0x40000001, &LD_GP_           , 0,
        MIPS64_             },        /* LD[GP] */
@@ -18993,7 +18986,7 @@ NMD::Pool NMD::P_GP_D[2] = {
 };
 
 
-NMD::Pool NMD::P_GP_W[4] = {
+static struct Pool P_GP_W[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc000003, 0x40000000, &ADDIU_GP_W_      , 0,
        0x0                 },        /* ADDIU[GP.W] */
@@ -19009,7 +19002,7 @@ NMD::Pool NMD::P_GP_W[4] = {
 };
 
 
-NMD::Pool NMD::POOL48I[32] = {
+static struct Pool POOL48I[32] = {
     { instruction         , 0                   , 0   , 48,
        0xfc1f00000000ull, 0x600000000000ull, &LI_48_           , 0,
        XMMS_               },        /* LI[48] */
@@ -19109,7 +19102,7 @@ NMD::Pool NMD::POOL48I[32] = {
 };
 
 
-NMD::Pool NMD::PP_SR[4] = {
+static struct Pool PP_SR[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc10f003, 0x80003000, &SAVE_32_         , 0,
        0x0                 },        /* SAVE[32] */
@@ -19125,7 +19118,7 @@ NMD::Pool NMD::PP_SR[4] = {
 };
 
 
-NMD::Pool NMD::P_SR_F[8] = {
+static struct Pool P_SR_F[8] = {
     { instruction         , 0                   , 0   , 32,
        0xfc10f007, 0x80103000, &SAVEF            , 0,
        CP1_                },        /* SAVEF */
@@ -19153,7 +19146,7 @@ NMD::Pool NMD::P_SR_F[8] = {
 };
 
 
-NMD::Pool NMD::P_SR[2] = {
+static struct Pool P_SR[2] = {
     { pool                , PP_SR               , 4   , 32,
        0xfc10f000, 0x80003000, 0                      , 0,
        0x0                 },        /* PP.SR */
@@ -19163,7 +19156,7 @@ NMD::Pool NMD::P_SR[2] = {
 };
 
 
-NMD::Pool NMD::P_SLL[5] = {
+static struct Pool P_SLL[5] = {
     { instruction         , 0                   , 0   , 32,
        0xffe0f1ff, 0x8000c000, &NOP_32_          , 0,
        0x0                 },        /* NOP[32] */
@@ -19182,7 +19175,7 @@ NMD::Pool NMD::P_SLL[5] = {
 };
 
 
-NMD::Pool NMD::P_SHIFT[16] = {
+static struct Pool P_SHIFT[16] = {
     { pool                , P_SLL               , 5   , 32,
        0xfc00f1e0, 0x8000c000, 0                      , 0,
        0x0                 },        /* P.SLL */
@@ -19234,7 +19227,7 @@ NMD::Pool NMD::P_SHIFT[16] = {
 };
 
 
-NMD::Pool NMD::P_ROTX[4] = {
+static struct Pool P_ROTX[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00f820, 0x8000d000, &ROTX             , 0,
        XMMS_               },        /* ROTX */
@@ -19250,7 +19243,7 @@ NMD::Pool NMD::P_ROTX[4] = {
 };
 
 
-NMD::Pool NMD::P_INS[4] = {
+static struct Pool P_INS[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00f820, 0x8000e000, &INS              , 0,
        XMMS_               },        /* INS */
@@ -19266,7 +19259,7 @@ NMD::Pool NMD::P_INS[4] = {
 };
 
 
-NMD::Pool NMD::P_EXT[4] = {
+static struct Pool P_EXT[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00f820, 0x8000f000, &EXT              , 0,
        XMMS_               },        /* EXT */
@@ -19282,7 +19275,7 @@ NMD::Pool NMD::P_EXT[4] = {
 };
 
 
-NMD::Pool NMD::P_U12[16] = {
+static struct Pool P_U12[16] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00f000, 0x80000000, &ORI              , 0,
        0x0                 },        /* ORI */
@@ -19334,7 +19327,7 @@ NMD::Pool NMD::P_U12[16] = {
 };
 
 
-NMD::Pool NMD::RINT_fmt[2] = {
+static struct Pool RINT_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000020, &RINT_S           , 0,
        CP1_                },        /* RINT.S */
@@ -19344,7 +19337,7 @@ NMD::Pool NMD::RINT_fmt[2] = {
 };
 
 
-NMD::Pool NMD::ADD_fmt0[2] = {
+static struct Pool ADD_fmt0[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000030, &ADD_S            , 0,
        CP1_                },        /* ADD.S */
@@ -19354,7 +19347,7 @@ NMD::Pool NMD::ADD_fmt0[2] = {
 };
 
 
-NMD::Pool NMD::SELEQZ_fmt[2] = {
+static struct Pool SELEQZ_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000038, &SELEQZ_S         , 0,
        CP1_                },        /* SELEQZ.S */
@@ -19364,7 +19357,7 @@ NMD::Pool NMD::SELEQZ_fmt[2] = {
 };
 
 
-NMD::Pool NMD::CLASS_fmt[2] = {
+static struct Pool CLASS_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000060, &CLASS_S          , 0,
        CP1_                },        /* CLASS.S */
@@ -19374,7 +19367,7 @@ NMD::Pool NMD::CLASS_fmt[2] = {
 };
 
 
-NMD::Pool NMD::SUB_fmt0[2] = {
+static struct Pool SUB_fmt0[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000070, &SUB_S            , 0,
        CP1_                },        /* SUB.S */
@@ -19384,7 +19377,7 @@ NMD::Pool NMD::SUB_fmt0[2] = {
 };
 
 
-NMD::Pool NMD::SELNEZ_fmt[2] = {
+static struct Pool SELNEZ_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000078, &SELNEZ_S         , 0,
        CP1_                },        /* SELNEZ.S */
@@ -19394,7 +19387,7 @@ NMD::Pool NMD::SELNEZ_fmt[2] = {
 };
 
 
-NMD::Pool NMD::MUL_fmt0[2] = {
+static struct Pool MUL_fmt0[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa00000b0, &MUL_S            , 0,
        CP1_                },        /* MUL.S */
@@ -19404,7 +19397,7 @@ NMD::Pool NMD::MUL_fmt0[2] = {
 };
 
 
-NMD::Pool NMD::SEL_fmt[2] = {
+static struct Pool SEL_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa00000b8, &SEL_S            , 0,
        CP1_                },        /* SEL.S */
@@ -19414,7 +19407,7 @@ NMD::Pool NMD::SEL_fmt[2] = {
 };
 
 
-NMD::Pool NMD::DIV_fmt0[2] = {
+static struct Pool DIV_fmt0[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa00000f0, &DIV_S            , 0,
        CP1_                },        /* DIV.S */
@@ -19424,7 +19417,7 @@ NMD::Pool NMD::DIV_fmt0[2] = {
 };
 
 
-NMD::Pool NMD::ADD_fmt1[2] = {
+static struct Pool ADD_fmt1[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000130, &ADD_D            , 0,
        CP1_                },        /* ADD.D */
@@ -19434,7 +19427,7 @@ NMD::Pool NMD::ADD_fmt1[2] = {
 };
 
 
-NMD::Pool NMD::SUB_fmt1[2] = {
+static struct Pool SUB_fmt1[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa0000170, &SUB_D            , 0,
        CP1_                },        /* SUB.D */
@@ -19444,7 +19437,7 @@ NMD::Pool NMD::SUB_fmt1[2] = {
 };
 
 
-NMD::Pool NMD::MUL_fmt1[2] = {
+static struct Pool MUL_fmt1[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa00001b0, &MUL_D            , 0,
        CP1_                },        /* MUL.D */
@@ -19454,7 +19447,7 @@ NMD::Pool NMD::MUL_fmt1[2] = {
 };
 
 
-NMD::Pool NMD::MADDF_fmt[2] = {
+static struct Pool MADDF_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa00001b8, &MADDF_S          , 0,
        CP1_                },        /* MADDF.S */
@@ -19464,7 +19457,7 @@ NMD::Pool NMD::MADDF_fmt[2] = {
 };
 
 
-NMD::Pool NMD::DIV_fmt1[2] = {
+static struct Pool DIV_fmt1[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa00001f0, &DIV_D            , 0,
        CP1_                },        /* DIV.D */
@@ -19474,7 +19467,7 @@ NMD::Pool NMD::DIV_fmt1[2] = {
 };
 
 
-NMD::Pool NMD::MSUBF_fmt[2] = {
+static struct Pool MSUBF_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0003ff, 0xa00001f8, &MSUBF_S          , 0,
        CP1_                },        /* MSUBF.S */
@@ -19484,7 +19477,7 @@ NMD::Pool NMD::MSUBF_fmt[2] = {
 };
 
 
-NMD::Pool NMD::POOL32F_0[64] = {
+static struct Pool POOL32F_0[64] = {
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0xa0000000, 0                      , 0,
        CP1_                },        /* POOL32F_0~*(0) */
@@ -19680,7 +19673,7 @@ NMD::Pool NMD::POOL32F_0[64] = {
 };
 
 
-NMD::Pool NMD::MIN_fmt[2] = {
+static struct Pool MIN_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00023f, 0xa0000003, &MIN_S            , 0,
        CP1_                },        /* MIN.S */
@@ -19690,7 +19683,7 @@ NMD::Pool NMD::MIN_fmt[2] = {
 };
 
 
-NMD::Pool NMD::MAX_fmt[2] = {
+static struct Pool MAX_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00023f, 0xa000000b, &MAX_S            , 0,
        CP1_                },        /* MAX.S */
@@ -19700,7 +19693,7 @@ NMD::Pool NMD::MAX_fmt[2] = {
 };
 
 
-NMD::Pool NMD::MINA_fmt[2] = {
+static struct Pool MINA_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00023f, 0xa0000023, &MINA_S           , 0,
        CP1_                },        /* MINA.S */
@@ -19710,7 +19703,7 @@ NMD::Pool NMD::MINA_fmt[2] = {
 };
 
 
-NMD::Pool NMD::MAXA_fmt[2] = {
+static struct Pool MAXA_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00023f, 0xa000002b, &MAXA_S           , 0,
        CP1_                },        /* MAXA.S */
@@ -19720,7 +19713,7 @@ NMD::Pool NMD::MAXA_fmt[2] = {
 };
 
 
-NMD::Pool NMD::CVT_L_fmt[2] = {
+static struct Pool CVT_L_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa000013b, &CVT_L_S          , 0,
        CP1_                },        /* CVT.L.S */
@@ -19730,7 +19723,7 @@ NMD::Pool NMD::CVT_L_fmt[2] = {
 };
 
 
-NMD::Pool NMD::RSQRT_fmt[2] = {
+static struct Pool RSQRT_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa000023b, &RSQRT_S          , 0,
        CP1_                },        /* RSQRT.S */
@@ -19740,7 +19733,7 @@ NMD::Pool NMD::RSQRT_fmt[2] = {
 };
 
 
-NMD::Pool NMD::FLOOR_L_fmt[2] = {
+static struct Pool FLOOR_L_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa000033b, &FLOOR_L_S        , 0,
        CP1_                },        /* FLOOR.L.S */
@@ -19750,7 +19743,7 @@ NMD::Pool NMD::FLOOR_L_fmt[2] = {
 };
 
 
-NMD::Pool NMD::CVT_W_fmt[2] = {
+static struct Pool CVT_W_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa000093b, &CVT_W_S          , 0,
        CP1_                },        /* CVT.W.S */
@@ -19760,7 +19753,7 @@ NMD::Pool NMD::CVT_W_fmt[2] = {
 };
 
 
-NMD::Pool NMD::SQRT_fmt[2] = {
+static struct Pool SQRT_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa0000a3b, &SQRT_S           , 0,
        CP1_                },        /* SQRT.S */
@@ -19770,7 +19763,7 @@ NMD::Pool NMD::SQRT_fmt[2] = {
 };
 
 
-NMD::Pool NMD::FLOOR_W_fmt[2] = {
+static struct Pool FLOOR_W_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa0000b3b, &FLOOR_W_S        , 0,
        CP1_                },        /* FLOOR.W.S */
@@ -19780,7 +19773,7 @@ NMD::Pool NMD::FLOOR_W_fmt[2] = {
 };
 
 
-NMD::Pool NMD::RECIP_fmt[2] = {
+static struct Pool RECIP_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa000123b, &RECIP_S          , 0,
        CP1_                },        /* RECIP.S */
@@ -19790,7 +19783,7 @@ NMD::Pool NMD::RECIP_fmt[2] = {
 };
 
 
-NMD::Pool NMD::CEIL_L_fmt[2] = {
+static struct Pool CEIL_L_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa000133b, &CEIL_L_S         , 0,
        CP1_                },        /* CEIL.L.S */
@@ -19800,7 +19793,7 @@ NMD::Pool NMD::CEIL_L_fmt[2] = {
 };
 
 
-NMD::Pool NMD::CEIL_W_fmt[2] = {
+static struct Pool CEIL_W_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa0001b3b, &CEIL_W_S         , 0,
        CP1_                },        /* CEIL.W.S */
@@ -19810,7 +19803,7 @@ NMD::Pool NMD::CEIL_W_fmt[2] = {
 };
 
 
-NMD::Pool NMD::TRUNC_L_fmt[2] = {
+static struct Pool TRUNC_L_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa000233b, &TRUNC_L_S        , 0,
        CP1_                },        /* TRUNC.L.S */
@@ -19820,7 +19813,7 @@ NMD::Pool NMD::TRUNC_L_fmt[2] = {
 };
 
 
-NMD::Pool NMD::TRUNC_W_fmt[2] = {
+static struct Pool TRUNC_W_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa0002b3b, &TRUNC_W_S        , 0,
        CP1_                },        /* TRUNC.W.S */
@@ -19830,7 +19823,7 @@ NMD::Pool NMD::TRUNC_W_fmt[2] = {
 };
 
 
-NMD::Pool NMD::ROUND_L_fmt[2] = {
+static struct Pool ROUND_L_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa000333b, &ROUND_L_S        , 0,
        CP1_                },        /* ROUND.L.S */
@@ -19840,7 +19833,7 @@ NMD::Pool NMD::ROUND_L_fmt[2] = {
 };
 
 
-NMD::Pool NMD::ROUND_W_fmt[2] = {
+static struct Pool ROUND_W_fmt[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa0003b3b, &ROUND_W_S        , 0,
        CP1_                },        /* ROUND.W.S */
@@ -19850,7 +19843,7 @@ NMD::Pool NMD::ROUND_W_fmt[2] = {
 };
 
 
-NMD::Pool NMD::POOL32Fxf_0[64] = {
+static struct Pool POOL32Fxf_0[64] = {
     { reserved_block      , 0                   , 0   , 32,
        0xfc003fff, 0xa000003b, 0                      , 0,
        CP1_                },        /* POOL32Fxf_0~*(0) */
@@ -20046,7 +20039,7 @@ NMD::Pool NMD::POOL32Fxf_0[64] = {
 };
 
 
-NMD::Pool NMD::MOV_fmt[4] = {
+static struct Pool MOV_fmt[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa000007b, &MOV_S            , 0,
        CP1_                },        /* MOV.S */
@@ -20062,7 +20055,7 @@ NMD::Pool NMD::MOV_fmt[4] = {
 };
 
 
-NMD::Pool NMD::ABS_fmt[4] = {
+static struct Pool ABS_fmt[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa000037b, &ABS_S            , 0,
        CP1_                },        /* ABS.S */
@@ -20078,7 +20071,7 @@ NMD::Pool NMD::ABS_fmt[4] = {
 };
 
 
-NMD::Pool NMD::NEG_fmt[4] = {
+static struct Pool NEG_fmt[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa0000b7b, &NEG_S            , 0,
        CP1_                },        /* NEG.S */
@@ -20094,7 +20087,7 @@ NMD::Pool NMD::NEG_fmt[4] = {
 };
 
 
-NMD::Pool NMD::CVT_D_fmt[4] = {
+static struct Pool CVT_D_fmt[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa000137b, &CVT_D_S          , 0,
        CP1_                },        /* CVT.D.S */
@@ -20110,7 +20103,7 @@ NMD::Pool NMD::CVT_D_fmt[4] = {
 };
 
 
-NMD::Pool NMD::CVT_S_fmt[4] = {
+static struct Pool CVT_S_fmt[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007fff, 0xa0001b7b, &CVT_S_D          , 0,
        CP1_                },        /* CVT.S.D */
@@ -20126,7 +20119,7 @@ NMD::Pool NMD::CVT_S_fmt[4] = {
 };
 
 
-NMD::Pool NMD::POOL32Fxf_1[32] = {
+static struct Pool POOL32Fxf_1[32] = {
     { pool                , MOV_fmt             , 4   , 32,
        0xfc001fff, 0xa000007b, 0                      , 0,
        CP1_                },        /* MOV.fmt */
@@ -20226,7 +20219,7 @@ NMD::Pool NMD::POOL32Fxf_1[32] = {
 };
 
 
-NMD::Pool NMD::POOL32Fxf[4] = {
+static struct Pool POOL32Fxf[4] = {
     { pool                , POOL32Fxf_0         , 64  , 32,
        0xfc0000ff, 0xa000003b, 0                      , 0,
        CP1_                },        /* POOL32Fxf_0 */
@@ -20242,7 +20235,7 @@ NMD::Pool NMD::POOL32Fxf[4] = {
 };
 
 
-NMD::Pool NMD::POOL32F_3[8] = {
+static struct Pool POOL32F_3[8] = {
     { pool                , MIN_fmt             , 2   , 32,
        0xfc00003f, 0xa0000003, 0                      , 0,
        CP1_                },        /* MIN.fmt */
@@ -20270,7 +20263,7 @@ NMD::Pool NMD::POOL32F_3[8] = {
 };
 
 
-NMD::Pool NMD::CMP_condn_S[32] = {
+static struct Pool CMP_condn_S[32] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0xa0000005, &CMP_AF_S         , 0,
        CP1_                },        /* CMP.AF.S */
@@ -20370,7 +20363,7 @@ NMD::Pool NMD::CMP_condn_S[32] = {
 };
 
 
-NMD::Pool NMD::CMP_condn_D[32] = {
+static struct Pool CMP_condn_D[32] = {
     { instruction         , 0                   , 0   , 32,
        0xfc0007ff, 0xa0000015, &CMP_AF_D         , 0,
        CP1_                },        /* CMP.AF.D */
@@ -20470,7 +20463,7 @@ NMD::Pool NMD::CMP_condn_D[32] = {
 };
 
 
-NMD::Pool NMD::POOL32F_5[8] = {
+static struct Pool POOL32F_5[8] = {
     { pool                , CMP_condn_S         , 32  , 32,
        0xfc00003f, 0xa0000005, 0                      , 0,
        CP1_                },        /* CMP.condn.S */
@@ -20498,7 +20491,7 @@ NMD::Pool NMD::POOL32F_5[8] = {
 };
 
 
-NMD::Pool NMD::POOL32F[8] = {
+static struct Pool POOL32F[8] = {
     { pool                , POOL32F_0           , 64  , 32,
        0xfc000007, 0xa0000000, 0                      , 0,
        CP1_                },        /* POOL32F_0 */
@@ -20526,7 +20519,7 @@ NMD::Pool NMD::POOL32F[8] = {
 };
 
 
-NMD::Pool NMD::POOL32S_0[64] = {
+static struct Pool POOL32S_0[64] = {
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0xc0000000, 0                      , 0,
        0x0                 },        /* POOL32S_0~*(0) */
@@ -20722,7 +20715,7 @@ NMD::Pool NMD::POOL32S_0[64] = {
 };
 
 
-NMD::Pool NMD::POOL32Sxf_4[128] = {
+static struct Pool POOL32Sxf_4[128] = {
     { reserved_block      , 0                   , 0   , 32,
        0xfc00ffff, 0xc000013c, 0                      , 0,
        0x0                 },        /* POOL32Sxf_4~*(0) */
@@ -21110,7 +21103,7 @@ NMD::Pool NMD::POOL32Sxf_4[128] = {
 };
 
 
-NMD::Pool NMD::POOL32Sxf[8] = {
+static struct Pool POOL32Sxf[8] = {
     { reserved_block      , 0                   , 0   , 32,
        0xfc0001ff, 0xc000003c, 0                      , 0,
        0x0                 },        /* POOL32Sxf~*(0) */
@@ -21138,7 +21131,7 @@ NMD::Pool NMD::POOL32Sxf[8] = {
 };
 
 
-NMD::Pool NMD::POOL32S_4[8] = {
+static struct Pool POOL32S_4[8] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00003f, 0xc0000004, &EXTD             , 0,
        MIPS64_             },        /* EXTD */
@@ -21166,7 +21159,7 @@ NMD::Pool NMD::POOL32S_4[8] = {
 };
 
 
-NMD::Pool NMD::POOL32S[8] = {
+static struct Pool POOL32S[8] = {
     { pool                , POOL32S_0           , 64  , 32,
        0xfc000007, 0xc0000000, 0                      , 0,
        0x0                 },        /* POOL32S_0 */
@@ -21194,7 +21187,7 @@ NMD::Pool NMD::POOL32S[8] = {
 };
 
 
-NMD::Pool NMD::P_LUI[2] = {
+static struct Pool P_LUI[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc000002, 0xe0000000, &LUI              , 0,
        0x0                 },        /* LUI */
@@ -21204,7 +21197,7 @@ NMD::Pool NMD::P_LUI[2] = {
 };
 
 
-NMD::Pool NMD::P_GP_LH[2] = {
+static struct Pool P_GP_LH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc1c0001, 0x44100000, &LH_GP_           , 0,
        0x0                 },        /* LH[GP] */
@@ -21214,7 +21207,7 @@ NMD::Pool NMD::P_GP_LH[2] = {
 };
 
 
-NMD::Pool NMD::P_GP_SH[2] = {
+static struct Pool P_GP_SH[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc1c0001, 0x44140000, &SH_GP_           , 0,
        0x0                 },        /* SH[GP] */
@@ -21224,7 +21217,7 @@ NMD::Pool NMD::P_GP_SH[2] = {
 };
 
 
-NMD::Pool NMD::P_GP_CP1[4] = {
+static struct Pool P_GP_CP1[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc1c0003, 0x44180000, &LWC1_GP_         , 0,
        CP1_                },        /* LWC1[GP] */
@@ -21240,7 +21233,7 @@ NMD::Pool NMD::P_GP_CP1[4] = {
 };
 
 
-NMD::Pool NMD::P_GP_M64[4] = {
+static struct Pool P_GP_M64[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc1c0003, 0x441c0000, &LWU_GP_          , 0,
        MIPS64_             },        /* LWU[GP] */
@@ -21256,7 +21249,7 @@ NMD::Pool NMD::P_GP_M64[4] = {
 };
 
 
-NMD::Pool NMD::P_GP_BH[8] = {
+static struct Pool P_GP_BH[8] = {
     { instruction         , 0                   , 0   , 32,
        0xfc1c0000, 0x44000000, &LB_GP_           , 0,
        0x0                 },        /* LB[GP] */
@@ -21284,7 +21277,7 @@ NMD::Pool NMD::P_GP_BH[8] = {
 };
 
 
-NMD::Pool NMD::P_LS_U12[16] = {
+static struct Pool P_LS_U12[16] = {
     { instruction         , 0                   , 0   , 32,
        0xfc00f000, 0x84000000, &LB_U12_          , 0,
        0x0                 },        /* LB[U12] */
@@ -21336,7 +21329,7 @@ NMD::Pool NMD::P_LS_U12[16] = {
 };
 
 
-NMD::Pool NMD::P_PREF_S9_[2] = {
+static struct Pool P_PREF_S9_[2] = {
     { instruction         , 0                   , 0   , 32,
        0xffe07f00, 0xa7e01800, &SYNCI            , 0,
        0x0                 },        /* SYNCI */
@@ -21346,7 +21339,7 @@ NMD::Pool NMD::P_PREF_S9_[2] = {
 };
 
 
-NMD::Pool NMD::P_LS_S0[16] = {
+static struct Pool P_LS_S0[16] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007f00, 0xa4000000, &LB_S9_           , 0,
        0x0                 },        /* LB[S9] */
@@ -21398,7 +21391,7 @@ NMD::Pool NMD::P_LS_S0[16] = {
 };
 
 
-NMD::Pool NMD::ASET_ACLR[2] = {
+static struct Pool ASET_ACLR[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfe007f00, 0xa4001100, &ASET             , 0,
        MCU_                },        /* ASET */
@@ -21408,7 +21401,7 @@ NMD::Pool NMD::ASET_ACLR[2] = {
 };
 
 
-NMD::Pool NMD::P_LL[4] = {
+static struct Pool P_LL[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007f03, 0xa4005100, &LL               , 0,
        0x0                 },        /* LL */
@@ -21424,7 +21417,7 @@ NMD::Pool NMD::P_LL[4] = {
 };
 
 
-NMD::Pool NMD::P_SC[4] = {
+static struct Pool P_SC[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007f03, 0xa4005900, &SC               , 0,
        0x0                 },        /* SC */
@@ -21440,7 +21433,7 @@ NMD::Pool NMD::P_SC[4] = {
 };
 
 
-NMD::Pool NMD::P_LLD[8] = {
+static struct Pool P_LLD[8] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007f07, 0xa4007100, &LLD              , 0,
        MIPS64_             },        /* LLD */
@@ -21468,7 +21461,7 @@ NMD::Pool NMD::P_LLD[8] = {
 };
 
 
-NMD::Pool NMD::P_SCD[8] = {
+static struct Pool P_SCD[8] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007f07, 0xa4007900, &SCD              , 0,
        MIPS64_             },        /* SCD */
@@ -21496,7 +21489,7 @@ NMD::Pool NMD::P_SCD[8] = {
 };
 
 
-NMD::Pool NMD::P_LS_S1[16] = {
+static struct Pool P_LS_S1[16] = {
     { reserved_block      , 0                   , 0   , 32,
        0xfc007f00, 0xa4000100, 0                      , 0,
        0x0                 },        /* P.LS.S1~*(0) */
@@ -21548,7 +21541,7 @@ NMD::Pool NMD::P_LS_S1[16] = {
 };
 
 
-NMD::Pool NMD::P_PREFE[2] = {
+static struct Pool P_PREFE[2] = {
     { instruction         , 0                   , 0   , 32,
        0xffe07f00, 0xa7e01a00, &SYNCIE           , 0,
        CP0_ | EVA_         },        /* SYNCIE */
@@ -21558,7 +21551,7 @@ NMD::Pool NMD::P_PREFE[2] = {
 };
 
 
-NMD::Pool NMD::P_LLE[4] = {
+static struct Pool P_LLE[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007f03, 0xa4005200, &LLE              , 0,
        CP0_ | EVA_         },        /* LLE */
@@ -21574,7 +21567,7 @@ NMD::Pool NMD::P_LLE[4] = {
 };
 
 
-NMD::Pool NMD::P_SCE[4] = {
+static struct Pool P_SCE[4] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007f03, 0xa4005a00, &SCE              , 0,
        CP0_ | EVA_         },        /* SCE */
@@ -21590,7 +21583,7 @@ NMD::Pool NMD::P_SCE[4] = {
 };
 
 
-NMD::Pool NMD::P_LS_E0[16] = {
+static struct Pool P_LS_E0[16] = {
     { instruction         , 0                   , 0   , 32,
        0xfc007f00, 0xa4000200, &LBE              , 0,
        CP0_ | EVA_         },        /* LBE */
@@ -21642,7 +21635,7 @@ NMD::Pool NMD::P_LS_E0[16] = {
 };
 
 
-NMD::Pool NMD::P_LS_WM[2] = {
+static struct Pool P_LS_WM[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc000f00, 0xa4000400, &LWM              , 0,
        XMMS_               },        /* LWM */
@@ -21652,7 +21645,7 @@ NMD::Pool NMD::P_LS_WM[2] = {
 };
 
 
-NMD::Pool NMD::P_LS_UAWM[2] = {
+static struct Pool P_LS_UAWM[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc000f00, 0xa4000500, &UALWM            , 0,
        XMMS_               },        /* UALWM */
@@ -21662,7 +21655,7 @@ NMD::Pool NMD::P_LS_UAWM[2] = {
 };
 
 
-NMD::Pool NMD::P_LS_DM[2] = {
+static struct Pool P_LS_DM[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc000f00, 0xa4000600, &LDM              , 0,
        MIPS64_             },        /* LDM */
@@ -21672,7 +21665,7 @@ NMD::Pool NMD::P_LS_DM[2] = {
 };
 
 
-NMD::Pool NMD::P_LS_UADM[2] = {
+static struct Pool P_LS_UADM[2] = {
     { instruction         , 0                   , 0   , 32,
        0xfc000f00, 0xa4000700, &UALDM            , 0,
        MIPS64_             },        /* UALDM */
@@ -21682,7 +21675,7 @@ NMD::Pool NMD::P_LS_UADM[2] = {
 };
 
 
-NMD::Pool NMD::P_LS_S9[8] = {
+static struct Pool P_LS_S9[8] = {
     { pool                , P_LS_S0             , 16  , 32,
        0xfc000700, 0xa4000000, 0                      , 0,
        0x0                 },        /* P.LS.S0 */
@@ -21710,7 +21703,7 @@ NMD::Pool NMD::P_LS_S9[8] = {
 };
 
 
-NMD::Pool NMD::P_BAL[2] = {
+static struct Pool P_BAL[2] = {
     { branch_instruction  , 0                   , 0   , 32,
        0xfe000000, 0x28000000, &BC_32_           , 0,
        0x0                 },        /* BC[32] */
@@ -21720,7 +21713,7 @@ NMD::Pool NMD::P_BAL[2] = {
 };
 
 
-NMD::Pool NMD::P_BALRSC[2] = {
+static struct Pool P_BALRSC[2] = {
     { branch_instruction  , 0                   , 0   , 32,
        0xffe0f000, 0x48008000, &BRSC             , 0,
        0x0                 },        /* BRSC */
@@ -21730,7 +21723,7 @@ NMD::Pool NMD::P_BALRSC[2] = {
 };
 
 
-NMD::Pool NMD::P_J[16] = {
+static struct Pool P_J[16] = {
     { call_instruction    , 0                   , 0   , 32,
        0xfc00f000, 0x48000000, &JALRC_32_        , 0,
        0x0                 },        /* JALRC[32] */
@@ -21782,7 +21775,7 @@ NMD::Pool NMD::P_J[16] = {
 };
 
 
-NMD::Pool NMD::P_BR3A[32] = {
+static struct Pool P_BR3A[32] = {
     { branch_instruction  , 0                   , 0   , 32,
        0xfc1fc000, 0x88004000, &BC1EQZC          , 0,
        CP1_                },        /* BC1EQZC */
@@ -21882,7 +21875,7 @@ NMD::Pool NMD::P_BR3A[32] = {
 };
 
 
-NMD::Pool NMD::P_BR1[4] = {
+static struct Pool P_BR1[4] = {
     { branch_instruction  , 0                   , 0   , 32,
        0xfc00c000, 0x88000000, &BEQC_32_         , 0,
        0x0                 },        /* BEQC[32] */
@@ -21898,7 +21891,7 @@ NMD::Pool NMD::P_BR1[4] = {
 };
 
 
-NMD::Pool NMD::P_BR2[4] = {
+static struct Pool P_BR2[4] = {
     { branch_instruction  , 0                   , 0   , 32,
        0xfc00c000, 0xa8000000, &BNEC_32_         , 0,
        0x0                 },        /* BNEC[32] */
@@ -21914,7 +21907,7 @@ NMD::Pool NMD::P_BR2[4] = {
 };
 
 
-NMD::Pool NMD::P_BRI[8] = {
+static struct Pool P_BRI[8] = {
     { branch_instruction  , 0                   , 0   , 32,
        0xfc1c0000, 0xc8000000, &BEQIC            , 0,
        0x0                 },        /* BEQIC */
@@ -21942,7 +21935,7 @@ NMD::Pool NMD::P_BRI[8] = {
 };
 
 
-NMD::Pool NMD::P32[32] = {
+static struct Pool P32[32] = {
     { pool                , P_ADDIU             , 2   , 32,
        0xfc000000, 0x00000000, 0                      , 0,
        0x0                 },        /* P.ADDIU */
@@ -22042,7 +22035,7 @@ NMD::Pool NMD::P32[32] = {
 };
 
 
-NMD::Pool NMD::P16_SYSCALL[2] = {
+static struct Pool P16_SYSCALL[2] = {
     { instruction         , 0                   , 0   , 16,
        0xfffc    , 0x1008    , &SYSCALL_16_      , 0,
        0x0                 },        /* SYSCALL[16] */
@@ -22052,7 +22045,7 @@ NMD::Pool NMD::P16_SYSCALL[2] = {
 };
 
 
-NMD::Pool NMD::P16_RI[4] = {
+static struct Pool P16_RI[4] = {
     { reserved_block      , 0                   , 0   , 16,
        0xfff8    , 0x1000    , 0                      , 0,
        0x0                 },        /* P16.RI~*(0) */
@@ -22068,7 +22061,7 @@ NMD::Pool NMD::P16_RI[4] = {
 };
 
 
-NMD::Pool NMD::P16_MV[2] = {
+static struct Pool P16_MV[2] = {
     { pool                , P16_RI              , 4   , 16,
        0xffe0    , 0x1000    , 0                      , 0,
        0x0                 },        /* P16.RI */
@@ -22078,7 +22071,7 @@ NMD::Pool NMD::P16_MV[2] = {
 };
 
 
-NMD::Pool NMD::P16_SHIFT[2] = {
+static struct Pool P16_SHIFT[2] = {
     { instruction         , 0                   , 0   , 16,
        0xfc08    , 0x3000    , &SLL_16_          , 0,
        0x0                 },        /* SLL[16] */
@@ -22088,7 +22081,7 @@ NMD::Pool NMD::P16_SHIFT[2] = {
 };
 
 
-NMD::Pool NMD::POOL16C_00[4] = {
+static struct Pool POOL16C_00[4] = {
     { instruction         , 0                   , 0   , 16,
        0xfc0f    , 0x5000    , &NOT_16_          , 0,
        0x0                 },        /* NOT[16] */
@@ -22104,7 +22097,7 @@ NMD::Pool NMD::POOL16C_00[4] = {
 };
 
 
-NMD::Pool NMD::POOL16C_0[2] = {
+static struct Pool POOL16C_0[2] = {
     { pool                , POOL16C_00          , 4   , 16,
        0xfc03    , 0x5000    , 0                      , 0,
        0x0                 },        /* POOL16C_00 */
@@ -22114,7 +22107,7 @@ NMD::Pool NMD::POOL16C_0[2] = {
 };
 
 
-NMD::Pool NMD::P16C[2] = {
+static struct Pool P16C[2] = {
     { pool                , POOL16C_0           , 2   , 16,
        0xfc01    , 0x5000    , 0                      , 0,
        0x0                 },        /* POOL16C_0 */
@@ -22124,7 +22117,7 @@ NMD::Pool NMD::P16C[2] = {
 };
 
 
-NMD::Pool NMD::P16_A1[2] = {
+static struct Pool P16_A1[2] = {
     { reserved_block      , 0                   , 0   , 16,
        0xfc40    , 0x7000    , 0                      , 0,
        0x0                 },        /* P16.A1~*(0) */
@@ -22134,7 +22127,7 @@ NMD::Pool NMD::P16_A1[2] = {
 };
 
 
-NMD::Pool NMD::P_ADDIU_RS5_[2] = {
+static struct Pool P_ADDIU_RS5_[2] = {
     { instruction         , 0                   , 0   , 16,
        0xffe8    , 0x9008    , &NOP_16_          , 0,
        0x0                 },        /* NOP[16] */
@@ -22144,7 +22137,7 @@ NMD::Pool NMD::P_ADDIU_RS5_[2] = {
 };
 
 
-NMD::Pool NMD::P16_A2[2] = {
+static struct Pool P16_A2[2] = {
     { instruction         , 0                   , 0   , 16,
        0xfc08    , 0x9000    , &ADDIU_R2_        , 0,
        0x0                 },        /* ADDIU[R2] */
@@ -22154,7 +22147,7 @@ NMD::Pool NMD::P16_A2[2] = {
 };
 
 
-NMD::Pool NMD::P16_ADDU[2] = {
+static struct Pool P16_ADDU[2] = {
     { instruction         , 0                   , 0   , 16,
        0xfc01    , 0xb000    , &ADDU_16_         , 0,
        0x0                 },        /* ADDU[16] */
@@ -22164,7 +22157,7 @@ NMD::Pool NMD::P16_ADDU[2] = {
 };
 
 
-NMD::Pool NMD::P16_JRC[2] = {
+static struct Pool P16_JRC[2] = {
     { branch_instruction  , 0                   , 0   , 16,
        0xfc1f    , 0xd800    , &JRC              , 0,
        0x0                 },        /* JRC */
@@ -22174,7 +22167,7 @@ NMD::Pool NMD::P16_JRC[2] = {
 };
 
 
-NMD::Pool NMD::P16_BR1[2] = {
+static struct Pool P16_BR1[2] = {
     { branch_instruction  , 0                   , 0   , 16,
        0xfc00    , 0xd800    , &BEQC_16_         , &BEQC_16__cond    ,
        XMMS_               },        /* BEQC[16] */
@@ -22184,7 +22177,7 @@ NMD::Pool NMD::P16_BR1[2] = {
 };
 
 
-NMD::Pool NMD::P16_BR[2] = {
+static struct Pool P16_BR[2] = {
     { pool                , P16_JRC             , 2   , 16,
        0xfc0f    , 0xd800    , 0                      , 0,
        0x0                 },        /* P16.JRC */
@@ -22194,7 +22187,7 @@ NMD::Pool NMD::P16_BR[2] = {
 };
 
 
-NMD::Pool NMD::P16_SR[2] = {
+static struct Pool P16_SR[2] = {
     { instruction         , 0                   , 0   , 16,
        0xfd00    , 0x1c00    , &SAVE_16_         , 0,
        0x0                 },        /* SAVE[16] */
@@ -22204,7 +22197,7 @@ NMD::Pool NMD::P16_SR[2] = {
 };
 
 
-NMD::Pool NMD::P16_4X4[4] = {
+static struct Pool P16_4X4[4] = {
     { instruction         , 0                   , 0   , 16,
        0xfd08    , 0x3c00    , &ADDU_4X4_        , 0,
        XMMS_               },        /* ADDU[4X4] */
@@ -22220,7 +22213,7 @@ NMD::Pool NMD::P16_4X4[4] = {
 };
 
 
-NMD::Pool NMD::P16_LB[4] = {
+static struct Pool P16_LB[4] = {
     { instruction         , 0                   , 0   , 16,
        0xfc0c    , 0x5c00    , &LB_16_           , 0,
        0x0                 },        /* LB[16] */
@@ -22236,7 +22229,7 @@ NMD::Pool NMD::P16_LB[4] = {
 };
 
 
-NMD::Pool NMD::P16_LH[4] = {
+static struct Pool P16_LH[4] = {
     { instruction         , 0                   , 0   , 16,
        0xfc09    , 0x7c00    , &LH_16_           , 0,
        0x0                 },        /* LH[16] */
@@ -22252,7 +22245,7 @@ NMD::Pool NMD::P16_LH[4] = {
 };
 
 
-NMD::Pool NMD::P16[32] = {
+static struct Pool P16[32] = {
     { pool                , P16_MV              , 2   , 16,
        0xfc00    , 0x1000    , 0                      , 0,
        0x0                 },        /* P16.MV */
@@ -22352,7 +22345,7 @@ NMD::Pool NMD::P16[32] = {
 };
 
 
-NMD::Pool NMD::MAJOR[2] = {
+static struct Pool MAJOR[2] = {
     { pool                , P32                 , 32  , 32,
        0x10000000, 0x00000000, 0                      , 0,
        0x0                 },        /* P32 */
@@ -22360,3 +22353,9 @@ NMD::Pool NMD::MAJOR[2] = {
        0x1000    , 0x1000    , 0                      , 0,
        0x0                 },        /* P16 */
 };
+
+int NMD::Disassemble(const uint16 * data, std::string & dis,
+                     TABLE_ENTRY_TYPE & type, img_address m_pc)
+{
+    return Disassemble(data, dis, type, MAJOR, 2, m_pc);
+}
diff --git a/disas/nanomips.h b/disas/nanomips.h
index dead0bcb94..4cdceb2279 100644
--- a/disas/nanomips.h
+++ b/disas/nanomips.h
@@ -64,6 +64,18 @@ enum TABLE_ATTRIBUTE_TYPE {
     ALL_ATTRIBUTES = 0xffffffffull,
 };
 
+struct Pool {
+    TABLE_ENTRY_TYPE     type;
+    struct Pool          *next_table;
+    int                  next_table_size;
+    int                  instructions_size;
+    uint64               mask;
+    uint64               value;
+    disassembly_function disassembly;
+    conditional_function condition;
+    uint64               attributes;
+};
+
 
 class NMD
 {
@@ -74,199 +86,11 @@ public:
 
 private:
 
-    struct Pool {
-        TABLE_ENTRY_TYPE     type;
-        struct Pool          *next_table;
-        int                  next_table_size;
-        int                  instructions_size;
-        uint64               mask;
-        uint64               value;
-        disassembly_function disassembly;
-        conditional_function condition;
-        uint64               attributes;
-    };
-
     uint64 extract_op_code_value(const uint16 *data, int size);
     int Disassemble(const uint16 *data, std::string & dis,
                     TABLE_ENTRY_TYPE & type, const Pool *table,
                     int table_size, img_address m_pc);
 
-    static Pool P_SYSCALL[2];
-    static Pool P_RI[4];
-    static Pool P_ADDIU[2];
-    static Pool P_TRAP[2];
-    static Pool P_CMOVE[2];
-    static Pool P_D_MT_VPE[2];
-    static Pool P_E_MT_VPE[2];
-    static Pool _P_MT_VPE[2];
-    static Pool P_MT_VPE[8];
-    static Pool P_DVP[2];
-    static Pool P_SLTU[2];
-    static Pool _POOL32A0[128];
-    static Pool ADDQ__S__PH[2];
-    static Pool MUL__S__PH[2];
-    static Pool ADDQH__R__PH[2];
-    static Pool ADDQH__R__W[2];
-    static Pool ADDU__S__QB[2];
-    static Pool ADDU__S__PH[2];
-    static Pool ADDUH__R__QB[2];
-    static Pool SHRAV__R__PH[2];
-    static Pool SHRAV__R__QB[2];
-    static Pool SUBQ__S__PH[2];
-    static Pool SUBQH__R__PH[2];
-    static Pool SUBQH__R__W[2];
-    static Pool SUBU__S__QB[2];
-    static Pool SUBU__S__PH[2];
-    static Pool SHRA__R__PH[2];
-    static Pool SUBUH__R__QB[2];
-    static Pool SHLLV__S__PH[2];
-    static Pool SHLL__S__PH[4];
-    static Pool PRECR_SRA__R__PH_W[2];
-    static Pool _POOL32A5[128];
-    static Pool PP_LSX[16];
-    static Pool PP_LSXS[16];
-    static Pool P_LSX[2];
-    static Pool POOL32Axf_1_0[4];
-    static Pool POOL32Axf_1_1[4];
-    static Pool POOL32Axf_1_3[4];
-    static Pool POOL32Axf_1_4[2];
-    static Pool MAQ_S_A__W_PHR[2];
-    static Pool MAQ_S_A__W_PHL[2];
-    static Pool POOL32Axf_1_5[2];
-    static Pool POOL32Axf_1_7[4];
-    static Pool POOL32Axf_1[8];
-    static Pool POOL32Axf_2_DSP__0_7[8];
-    static Pool POOL32Axf_2_DSP__8_15[8];
-    static Pool POOL32Axf_2_DSP__16_23[8];
-    static Pool POOL32Axf_2_DSP__24_31[8];
-    static Pool POOL32Axf_2[4];
-    static Pool POOL32Axf_4[128];
-    static Pool POOL32Axf_5_group0[32];
-    static Pool POOL32Axf_5_group1[32];
-    static Pool ERETx[2];
-    static Pool POOL32Axf_5_group3[32];
-    static Pool POOL32Axf_5[4];
-    static Pool SHRA__R__QB[2];
-    static Pool POOL32Axf_7[8];
-    static Pool POOL32Axf[8];
-    static Pool _POOL32A7[8];
-    static Pool P32A[8];
-    static Pool P_GP_D[2];
-    static Pool P_GP_W[4];
-    static Pool POOL48I[32];
-    static Pool PP_SR[4];
-    static Pool P_SR_F[8];
-    static Pool P_SR[2];
-    static Pool P_SLL[5];
-    static Pool P_SHIFT[16];
-    static Pool P_ROTX[4];
-    static Pool P_INS[4];
-    static Pool P_EXT[4];
-    static Pool P_U12[16];
-    static Pool RINT_fmt[2];
-    static Pool ADD_fmt0[2];
-    static Pool SELEQZ_fmt[2];
-    static Pool CLASS_fmt[2];
-    static Pool SUB_fmt0[2];
-    static Pool SELNEZ_fmt[2];
-    static Pool MUL_fmt0[2];
-    static Pool SEL_fmt[2];
-    static Pool DIV_fmt0[2];
-    static Pool ADD_fmt1[2];
-    static Pool SUB_fmt1[2];
-    static Pool MUL_fmt1[2];
-    static Pool MADDF_fmt[2];
-    static Pool DIV_fmt1[2];
-    static Pool MSUBF_fmt[2];
-    static Pool POOL32F_0[64];
-    static Pool MIN_fmt[2];
-    static Pool MAX_fmt[2];
-    static Pool MINA_fmt[2];
-    static Pool MAXA_fmt[2];
-    static Pool CVT_L_fmt[2];
-    static Pool RSQRT_fmt[2];
-    static Pool FLOOR_L_fmt[2];
-    static Pool CVT_W_fmt[2];
-    static Pool SQRT_fmt[2];
-    static Pool FLOOR_W_fmt[2];
-    static Pool RECIP_fmt[2];
-    static Pool CEIL_L_fmt[2];
-    static Pool CEIL_W_fmt[2];
-    static Pool TRUNC_L_fmt[2];
-    static Pool TRUNC_W_fmt[2];
-    static Pool ROUND_L_fmt[2];
-    static Pool ROUND_W_fmt[2];
-    static Pool POOL32Fxf_0[64];
-    static Pool MOV_fmt[4];
-    static Pool ABS_fmt[4];
-    static Pool NEG_fmt[4];
-    static Pool CVT_D_fmt[4];
-    static Pool CVT_S_fmt[4];
-    static Pool POOL32Fxf_1[32];
-    static Pool POOL32Fxf[4];
-    static Pool POOL32F_3[8];
-    static Pool CMP_condn_S[32];
-    static Pool CMP_condn_D[32];
-    static Pool POOL32F_5[8];
-    static Pool POOL32F[8];
-    static Pool POOL32S_0[64];
-    static Pool POOL32Sxf_4[128];
-    static Pool POOL32Sxf[8];
-    static Pool POOL32S_4[8];
-    static Pool POOL32S[8];
-    static Pool P_LUI[2];
-    static Pool P_GP_LH[2];
-    static Pool P_GP_SH[2];
-    static Pool P_GP_CP1[4];
-    static Pool P_GP_M64[4];
-    static Pool P_GP_BH[8];
-    static Pool P_LS_U12[16];
-    static Pool P_PREF_S9_[2];
-    static Pool P_LS_S0[16];
-    static Pool ASET_ACLR[2];
-    static Pool P_LL[4];
-    static Pool P_SC[4];
-    static Pool P_LLD[8];
-    static Pool P_SCD[8];
-    static Pool P_LS_S1[16];
-    static Pool P_PREFE[2];
-    static Pool P_LLE[4];
-    static Pool P_SCE[4];
-    static Pool P_LS_E0[16];
-    static Pool P_LS_WM[2];
-    static Pool P_LS_UAWM[2];
-    static Pool P_LS_DM[2];
-    static Pool P_LS_UADM[2];
-    static Pool P_LS_S9[8];
-    static Pool P_BAL[2];
-    static Pool P_BALRSC[2];
-    static Pool P_J[16];
-    static Pool P_BR3A[32];
-    static Pool P_BR1[4];
-    static Pool P_BR2[4];
-    static Pool P_BRI[8];
-    static Pool P32[32];
-    static Pool P16_SYSCALL[2];
-    static Pool P16_RI[4];
-    static Pool P16_MV[2];
-    static Pool P16_SHIFT[2];
-    static Pool POOL16C_00[4];
-    static Pool POOL16C_0[2];
-    static Pool P16C[2];
-    static Pool P16_A1[2];
-    static Pool P_ADDIU_RS5_[2];
-    static Pool P16_A2[2];
-    static Pool P16_ADDU[2];
-    static Pool P16_JRC[2];
-    static Pool P16_BR1[2];
-    static Pool P16_BR[2];
-    static Pool P16_SR[2];
-    static Pool P16_4X4[4];
-    static Pool P16_LB[4];
-    static Pool P16_LH[4];
-    static Pool P16[32];
-    static Pool MAJOR[2];
-
 };
 
 #endif
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 07/20] disas/nanomips: Remove Pool tables from the class
  2022-09-05  9:55 ` [PATCH v2 07/20] disas/nanomips: Remove Pool tables from the class Milica Lazarevic
@ 2022-09-05 11:11   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:11 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic,
	Philippe Mathieu-Daudé

On 9/5/22 10:55, Milica Lazarevic wrote:
> Pool tables are no longer declared as static fields of the NMD
> class but as global static variables.
> 
> The NMD::Disassemble method is using the MAJOR Pool table variable, so
> its implementation is moved to the end of the nanomips.cpp file,
> right after the initialization of the MAJOR Pool table.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> Reviewed-by: Philippe Mathieu-Daudé<f4bug@amsat.org>
> ---
>   disas/nanomips.cpp | 363 ++++++++++++++++++++++-----------------------
>   disas/nanomips.h   | 200 ++-----------------------
>   2 files changed, 193 insertions(+), 370 deletions(-)

It would be nice if all of these were const.  That might require a separate patch in order 
to add const to users, or it might not.

Either way, this patch is fine,
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 08/20] disas/nanomips: Remove NMD class
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (6 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 07/20] disas/nanomips: Remove Pool tables from the class Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:13   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 09/20] disas/nanomips: Move typedefs etc to nanomips.cpp Milica Lazarevic
                   ` (11 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

NMD class has been deleted. The following methods are now declared as
static functions:
- public NMD::Disassemble method
- private NMD::Disassemble method
- private NMD::extract_op_code_value helper method

Also, the implementation of the print_insn_nanomips function and
nanomips_dis function is moved to the end of the nanomips.cpp file,
right after the implementation of the Disassemble function.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
---
 disas/nanomips.cpp | 202 ++++++++++++++++++++++-----------------------
 disas/nanomips.h   |  17 ----
 2 files changed, 100 insertions(+), 119 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index 37809ff365..1326840611 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -41,102 +41,6 @@
 #define IMGASSERTONCE(test)
 
 
-static int nanomips_dis(char *buf,
-                 unsigned address,
-                 unsigned short one,
-                 unsigned short two,
-                 unsigned short three)
-{
-    std::string disasm;
-    uint16 bits[3] = {one, two, three};
-
-    TABLE_ENTRY_TYPE type;
-    NMD d;
-    int size = d.Disassemble(bits, disasm, type, address);
-
-    strcpy(buf, disasm.c_str());
-    return size;
-}
-
-int print_insn_nanomips(bfd_vma memaddr, struct disassemble_info *info)
-{
-    int status;
-    bfd_byte buffer[2];
-    uint16_t insn1 = 0, insn2 = 0, insn3 = 0;
-    char buf[200];
-
-    info->bytes_per_chunk = 2;
-    info->display_endian = info->endian;
-    info->insn_info_valid = 1;
-    info->branch_delay_insns = 0;
-    info->data_size = 0;
-    info->insn_type = dis_nonbranch;
-    info->target = 0;
-    info->target2 = 0;
-
-    status = (*info->read_memory_func)(memaddr, buffer, 2, info);
-    if (status != 0) {
-        (*info->memory_error_func)(status, memaddr, info);
-        return -1;
-    }
-
-    if (info->endian == BFD_ENDIAN_BIG) {
-        insn1 = bfd_getb16(buffer);
-    } else {
-        insn1 = bfd_getl16(buffer);
-    }
-    (*info->fprintf_func)(info->stream, "%04x ", insn1);
-
-    /* Handle 32-bit opcodes.  */
-    if ((insn1 & 0x1000) == 0) {
-        status = (*info->read_memory_func)(memaddr + 2, buffer, 2, info);
-        if (status != 0) {
-            (*info->memory_error_func)(status, memaddr + 2, info);
-            return -1;
-        }
-
-        if (info->endian == BFD_ENDIAN_BIG) {
-            insn2 = bfd_getb16(buffer);
-        } else {
-            insn2 = bfd_getl16(buffer);
-        }
-        (*info->fprintf_func)(info->stream, "%04x ", insn2);
-    } else {
-        (*info->fprintf_func)(info->stream, "     ");
-    }
-    /* Handle 48-bit opcodes.  */
-    if ((insn1 >> 10) == 0x18) {
-        status = (*info->read_memory_func)(memaddr + 4, buffer, 2, info);
-        if (status != 0) {
-            (*info->memory_error_func)(status, memaddr + 4, info);
-            return -1;
-        }
-
-        if (info->endian == BFD_ENDIAN_BIG) {
-            insn3 = bfd_getb16(buffer);
-        } else {
-            insn3 = bfd_getl16(buffer);
-        }
-        (*info->fprintf_func)(info->stream, "%04x ", insn3);
-    } else {
-        (*info->fprintf_func)(info->stream, "     ");
-    }
-
-    int length = nanomips_dis(buf, memaddr, insn1, insn2, insn3);
-
-    /* FIXME: Should probably use a hash table on the major opcode here.  */
-
-    (*info->fprintf_func) (info->stream, "%s", buf);
-    if (length > 0) {
-        return length / 8;
-    }
-
-    info->insn_type = dis_noninsn;
-
-    return insn3 ? 6 : insn2 ? 4 : 2;
-}
-
-
 std::string img_format(const char *format, ...)
 {
     char buffer[256];
@@ -736,7 +640,7 @@ static std::string ADDRESS(uint64 value, int instruction_size, img_address m_pc)
 }
 
 
-uint64 NMD::extract_op_code_value(const uint16 * data, int size)
+static uint64 extract_op_code_value(const uint16 *data, int size)
 {
     switch (size) {
     case 16:
@@ -762,9 +666,9 @@ uint64 NMD::extract_op_code_value(const uint16 * data, int size)
  *      instruction size    - negative is error
  *      disassembly string  - on error will constain error string
  */
-int NMD::Disassemble(const uint16 * data, std::string & dis,
-                     TABLE_ENTRY_TYPE & type, const Pool *table,
-                     int table_size, img_address m_pc)
+static int Disassemble(const uint16 *data, std::string & dis,
+                       TABLE_ENTRY_TYPE & type, const Pool *table,
+                       int table_size, img_address m_pc)
 {
     try
     {
@@ -22354,8 +22258,102 @@ static struct Pool MAJOR[2] = {
        0x0                 },        /* P16 */
 };
 
-int NMD::Disassemble(const uint16 * data, std::string & dis,
-                     TABLE_ENTRY_TYPE & type, img_address m_pc)
+static int Disassemble(const uint16 *data, std::string & dis,
+                       TABLE_ENTRY_TYPE & type, img_address m_pc)
 {
     return Disassemble(data, dis, type, MAJOR, 2, m_pc);
 }
+
+static int nanomips_dis(char *buf,
+                 unsigned address,
+                 unsigned short one,
+                 unsigned short two,
+                 unsigned short three)
+{
+    std::string disasm;
+    uint16 bits[3] = {one, two, three};
+
+    TABLE_ENTRY_TYPE type;
+    int size = Disassemble(bits, disasm, type, address);
+
+    strcpy(buf, disasm.c_str());
+    return size;
+}
+
+int print_insn_nanomips(bfd_vma memaddr, struct disassemble_info *info)
+{
+    int status;
+    bfd_byte buffer[2];
+    uint16_t insn1 = 0, insn2 = 0, insn3 = 0;
+    char buf[200];
+
+    info->bytes_per_chunk = 2;
+    info->display_endian = info->endian;
+    info->insn_info_valid = 1;
+    info->branch_delay_insns = 0;
+    info->data_size = 0;
+    info->insn_type = dis_nonbranch;
+    info->target = 0;
+    info->target2 = 0;
+
+    status = (*info->read_memory_func)(memaddr, buffer, 2, info);
+    if (status != 0) {
+        (*info->memory_error_func)(status, memaddr, info);
+        return -1;
+    }
+
+    if (info->endian == BFD_ENDIAN_BIG) {
+        insn1 = bfd_getb16(buffer);
+    } else {
+        insn1 = bfd_getl16(buffer);
+    }
+    (*info->fprintf_func)(info->stream, "%04x ", insn1);
+
+    /* Handle 32-bit opcodes.  */
+    if ((insn1 & 0x1000) == 0) {
+        status = (*info->read_memory_func)(memaddr + 2, buffer, 2, info);
+        if (status != 0) {
+            (*info->memory_error_func)(status, memaddr + 2, info);
+            return -1;
+        }
+
+        if (info->endian == BFD_ENDIAN_BIG) {
+            insn2 = bfd_getb16(buffer);
+        } else {
+            insn2 = bfd_getl16(buffer);
+        }
+        (*info->fprintf_func)(info->stream, "%04x ", insn2);
+    } else {
+        (*info->fprintf_func)(info->stream, "     ");
+    }
+    /* Handle 48-bit opcodes.  */
+    if ((insn1 >> 10) == 0x18) {
+        status = (*info->read_memory_func)(memaddr + 4, buffer, 2, info);
+        if (status != 0) {
+            (*info->memory_error_func)(status, memaddr + 4, info);
+            return -1;
+        }
+
+        if (info->endian == BFD_ENDIAN_BIG) {
+            insn3 = bfd_getb16(buffer);
+        } else {
+            insn3 = bfd_getl16(buffer);
+        }
+        (*info->fprintf_func)(info->stream, "%04x ", insn3);
+    } else {
+        (*info->fprintf_func)(info->stream, "     ");
+    }
+
+    int length = nanomips_dis(buf, memaddr, insn1, insn2, insn3);
+
+    /* FIXME: Should probably use a hash table on the major opcode here.  */
+
+    (*info->fprintf_func) (info->stream, "%s", buf);
+    if (length > 0) {
+        return length / 8;
+    }
+
+    info->insn_type = dis_noninsn;
+
+    return insn3 ? 6 : insn2 ? 4 : 2;
+}
diff --git a/disas/nanomips.h b/disas/nanomips.h
index 4cdceb2279..04f57c26ea 100644
--- a/disas/nanomips.h
+++ b/disas/nanomips.h
@@ -76,21 +76,4 @@ struct Pool {
     uint64               attributes;
 };
 
-
-class NMD
-{
-public:
-
-    int Disassemble(const uint16 *data, std::string & dis,
-                    TABLE_ENTRY_TYPE & type, img_address m_pc);
-
-private:
-
-    uint64 extract_op_code_value(const uint16 *data, int size);
-    int Disassemble(const uint16 *data, std::string & dis,
-                    TABLE_ENTRY_TYPE & type, const Pool *table,
-                    int table_size, img_address m_pc);
-
-};
-
 #endif
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 08/20] disas/nanomips: Remove NMD class
  2022-09-05  9:55 ` [PATCH v2 08/20] disas/nanomips: Remove NMD class Milica Lazarevic
@ 2022-09-05 11:13   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:13 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> NMD class has been deleted. The following methods are now declared as
> static functions:
> - public NMD::Disassemble method
> - private NMD::Disassemble method
> - private NMD::extract_op_code_value helper method
> 
> Also, the implementation of the print_insn_nanomips function and
> nanomips_dis function is moved to the end of the nanomips.cpp file,
> right after the implementation of the Disassemble function.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> ---
>   disas/nanomips.cpp | 202 ++++++++++++++++++++++-----------------------
>   disas/nanomips.h   |  17 ----
>   2 files changed, 100 insertions(+), 119 deletions(-)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 09/20] disas/nanomips: Move typedefs etc to nanomips.cpp
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (7 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 08/20] disas/nanomips: Remove NMD class Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:14   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 10/20] disas/nanomips: Delete nanomips.h Milica Lazarevic
                   ` (10 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic, Philippe Mathieu-Daudé

The following is moved from the nanomips.h to nanomips.cpp file:
- #include line
- typedefs
- enums
- definition of the Pool struct.
Header file nanomips.h will be deleted to be consistent with the rest of
the disas/ code.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
---
 disas/nanomips.cpp | 53 +++++++++++++++++++++++++++++++++++++++++++++-
 disas/nanomips.h   | 53 ----------------------------------------------
 2 files changed, 52 insertions(+), 54 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index 1326840611..c11c0aceaf 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -36,7 +36,58 @@
 #include <stdio.h>
 #include <stdarg.h>
 
-#include "nanomips.h"
+#include <string>
+
+typedef int64_t int64;
+typedef uint64_t uint64;
+typedef uint32_t uint32;
+typedef uint16_t uint16;
+typedef uint64_t img_address;
+
+typedef bool (*conditional_function)(uint64 instruction);
+typedef std::string (*disassembly_function)(uint64 instruction,
+                                            img_address m_pc);
+
+enum TABLE_ENTRY_TYPE {
+    instruction,
+    call_instruction,
+    branch_instruction,
+    return_instruction,
+    reserved_block,
+    pool,
+};
+
+enum TABLE_ATTRIBUTE_TYPE {
+    MIPS64_    = 0x00000001,
+    XNP_       = 0x00000002,
+    XMMS_      = 0x00000004,
+    EVA_       = 0x00000008,
+    DSP_       = 0x00000010,
+    MT_        = 0x00000020,
+    EJTAG_     = 0x00000040,
+    TLBINV_    = 0x00000080,
+    CP0_       = 0x00000100,
+    CP1_       = 0x00000200,
+    CP2_       = 0x00000400,
+    UDI_       = 0x00000800,
+    MCU_       = 0x00001000,
+    VZ_        = 0x00002000,
+    TLB_       = 0x00004000,
+    MVH_       = 0x00008000,
+    ALL_ATTRIBUTES = 0xffffffffull,
+};
+
+struct Pool {
+    TABLE_ENTRY_TYPE     type;
+    struct Pool          *next_table;
+    int                  next_table_size;
+    int                  instructions_size;
+    uint64               mask;
+    uint64               value;
+    disassembly_function disassembly;
+    conditional_function condition;
+    uint64               attributes;
+};
 
 #define IMGASSERTONCE(test)
 
diff --git a/disas/nanomips.h b/disas/nanomips.h
index 04f57c26ea..0fd7299900 100644
--- a/disas/nanomips.h
+++ b/disas/nanomips.h
@@ -23,57 +23,4 @@
 #ifndef DISAS_NANOMIPS_H
 #define DISAS_NANOMIPS_H
 
-#include <string>
-
-typedef int64_t int64;
-typedef uint64_t uint64;
-typedef uint32_t uint32;
-typedef uint16_t uint16;
-typedef uint64_t img_address;
-
-typedef bool (*conditional_function)(uint64 instruction);
-typedef std::string (*disassembly_function)(uint64 instruction,
-                                            img_address m_pc);
-
-enum TABLE_ENTRY_TYPE {
-    instruction,
-    call_instruction,
-    branch_instruction,
-    return_instruction,
-    reserved_block,
-    pool,
-};
-
-enum TABLE_ATTRIBUTE_TYPE {
-    MIPS64_    = 0x00000001,
-    XNP_       = 0x00000002,
-    XMMS_      = 0x00000004,
-    EVA_       = 0x00000008,
-    DSP_       = 0x00000010,
-    MT_        = 0x00000020,
-    EJTAG_     = 0x00000040,
-    TLBINV_    = 0x00000080,
-    CP0_       = 0x00000100,
-    CP1_       = 0x00000200,
-    CP2_       = 0x00000400,
-    UDI_       = 0x00000800,
-    MCU_       = 0x00001000,
-    VZ_        = 0x00002000,
-    TLB_       = 0x00004000,
-    MVH_       = 0x00008000,
-    ALL_ATTRIBUTES = 0xffffffffull,
-};
-
-struct Pool {
-    TABLE_ENTRY_TYPE     type;
-    struct Pool          *next_table;
-    int                  next_table_size;
-    int                  instructions_size;
-    uint64               mask;
-    uint64               value;
-    disassembly_function disassembly;
-    conditional_function condition;
-    uint64               attributes;
-};
-
 #endif
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 09/20] disas/nanomips: Move typedefs etc to nanomips.cpp
  2022-09-05  9:55 ` [PATCH v2 09/20] disas/nanomips: Move typedefs etc to nanomips.cpp Milica Lazarevic
@ 2022-09-05 11:14   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:14 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic,
	Philippe Mathieu-Daudé

On 9/5/22 10:55, Milica Lazarevic wrote:
> The following is moved from the nanomips.h to nanomips.cpp file:
> - #include line
> - typedefs
> - enums
> - definition of the Pool struct.
> Header file nanomips.h will be deleted to be consistent with the rest of
> the disas/ code.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> Reviewed-by: Philippe Mathieu-Daudé<f4bug@amsat.org>
> ---
>   disas/nanomips.cpp | 53 +++++++++++++++++++++++++++++++++++++++++++++-
>   disas/nanomips.h   | 53 ----------------------------------------------
>   2 files changed, 52 insertions(+), 54 deletions(-)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 10/20] disas/nanomips: Delete nanomips.h
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (8 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 09/20] disas/nanomips: Move typedefs etc to nanomips.cpp Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:14   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 11/20] disas/nanomips: Remove #inlcude <sstream> Milica Lazarevic
                   ` (9 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic, Philippe Mathieu-Daudé

Header file nanomips.h has been deleted for the nanomips disassembler to
stay consistent with the rest of the disassemblers which don't include
extra header files.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
---
 disas/nanomips.h | 26 --------------------------
 1 file changed, 26 deletions(-)
 delete mode 100644 disas/nanomips.h

diff --git a/disas/nanomips.h b/disas/nanomips.h
deleted file mode 100644
index 0fd7299900..0000000000
--- a/disas/nanomips.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- *  Header file for nanoMIPS disassembler component of QEMU
- *
- *  Copyright (C) 2018  Wave Computing, Inc.
- *  Copyright (C) 2018  Matthew Fortune <matthew.fortune@mips.com>
- *  Copyright (C) 2018  Aleksandar Markovic <amarkovic@wavecomp.com>
- *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef DISAS_NANOMIPS_H
-#define DISAS_NANOMIPS_H
-
-#endif
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 10/20] disas/nanomips: Delete nanomips.h
  2022-09-05  9:55 ` [PATCH v2 10/20] disas/nanomips: Delete nanomips.h Milica Lazarevic
@ 2022-09-05 11:14   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:14 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic,
	Philippe Mathieu-Daudé

On 9/5/22 10:55, Milica Lazarevic wrote:
> Header file nanomips.h has been deleted for the nanomips disassembler to
> stay consistent with the rest of the disassemblers which don't include
> extra header files.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> Reviewed-by: Philippe Mathieu-Daudé<f4bug@amsat.org>
> ---
>   disas/nanomips.h | 26 --------------------------
>   1 file changed, 26 deletions(-)
>   delete mode 100644 disas/nanomips.h

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 11/20] disas/nanomips: Remove #inlcude <sstream>
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (9 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 10/20] disas/nanomips: Delete nanomips.h Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:14   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 12/20] disas/nanomips: Replace std::string type Milica Lazarevic
                   ` (8 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

<sstream> is a C++ library and it's not used by disassembler.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
---
 disas/nanomips.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index c11c0aceaf..bfbd472150 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -32,7 +32,6 @@
 
 #include <cstring>
 #include <stdexcept>
-#include <sstream>
 #include <stdio.h>
 #include <stdarg.h>
 
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 11/20] disas/nanomips: Remove #inlcude <sstream>
  2022-09-05  9:55 ` [PATCH v2 11/20] disas/nanomips: Remove #inlcude <sstream> Milica Lazarevic
@ 2022-09-05 11:14   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:14 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> <sstream> is a C++ library and it's not used by disassembler.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> Reviewed-by: Thomas Huth<thuth@redhat.com>
> ---
>   disas/nanomips.cpp | 1 -
>   1 file changed, 1 deletion(-)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 12/20] disas/nanomips: Replace std::string type
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (10 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 11/20] disas/nanomips: Remove #inlcude <sstream> Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:32   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 13/20] disas/nanomips: Prevent memory leaking Milica Lazarevic
                   ` (7 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

The return type of typedef disassembly_function is changed to char *
instead of std::string. Therefore, for every particular
disassembly_function function signature is changed.
For example:
- static std::string ABS_D(uint64 instruction, img_address m_pc) {...}
is replaced with
- static char *ABS_D(uint64 instruction, img_address m_pc) {...}

Every helper function used to return std::string is changed to return
const char * or char *. Where the return value points to a static string
that the caller must not free, the return type is const char *. If a
function allocates memory and the caller is required to free it, the
return type is a char *. This applies to the following functions:
img_format, to_string, GPR, save_restore_list, FPR, etc.

Now that we replaced every std::string for const char * or char *, it is
possible to delete multiple versions of the img_format function. The
general version:
- static char *img_format(const char *format, ...) {...}
can handle all string formatting, so others have been deleted.

Where necessary, strings are dynamically allocated with g_malloc,
g_strdup_vprintf, and g_strdup_printf. Memory leaking will be prevented
later.

Simple assignments like:
- x = "string"
are handled using the strcpy() function where needed.

String concatenation in the save_restore_list() function is handled
using strcat() function instead of += operator.

Without applying all of these changes, the nanomips disassembler may be
buildable but can't produce the appropriate output, so all of them are
made together.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
---
 disas/nanomips.cpp | 4772 ++++++++++++++++++++++----------------------
 1 file changed, 2337 insertions(+), 2435 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index bfbd472150..cfea95130d 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -30,13 +30,11 @@
 #include "qemu/osdep.h"
 #include "disas/dis-asm.h"
 
-#include <cstring>
+#include <string.h>
 #include <stdexcept>
 #include <stdio.h>
 #include <stdarg.h>
 
-#include <string>
-
 typedef int64_t int64;
 typedef uint64_t uint64;
 typedef uint32_t uint32;
@@ -44,8 +42,8 @@ typedef uint16_t uint16;
 typedef uint64_t img_address;
 
 typedef bool (*conditional_function)(uint64 instruction);
-typedef std::string (*disassembly_function)(uint64 instruction,
-                                            img_address m_pc);
+typedef char * (*disassembly_function)(uint64 instruction,
+                                       img_address m_pc);
 
 enum TABLE_ENTRY_TYPE {
     instruction,
@@ -91,122 +89,20 @@ struct Pool {
 #define IMGASSERTONCE(test)
 
 
-std::string img_format(const char *format, ...)
+static char *img_format(const char *format, ...)
 {
-    char buffer[256];
+    char *buffer;
     va_list args;
     va_start(args, format);
-    int err = vsprintf(buffer, format, args);
-    if (err < 0) {
-        perror(buffer);
-    }
+    buffer = g_strdup_vprintf(format, args);
     va_end(args);
     return buffer;
 }
 
-std::string img_format(const char *format,
-                   std::string s)
-{
-    char buffer[256];
-
-    sprintf(buffer, format, s.c_str());
-
-    return buffer;
-}
-
-std::string img_format(const char *format,
-                   std::string s1,
-                   std::string s2)
-{
-    char buffer[256];
-
-    sprintf(buffer, format, s1.c_str(), s2.c_str());
-
-    return buffer;
-}
-
-std::string img_format(const char *format,
-                   std::string s1,
-                   std::string s2,
-                   std::string s3)
-{
-    char buffer[256];
-
-    sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str());
-
-    return buffer;
-}
-
-std::string img_format(const char *format,
-                   std::string s1,
-                   std::string s2,
-                   std::string s3,
-                   std::string s4)
-{
-    char buffer[256];
-
-    sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str(),
-                            s4.c_str());
-
-    return buffer;
-}
-
-std::string img_format(const char *format,
-                   std::string s1,
-                   std::string s2,
-                   std::string s3,
-                   std::string s4,
-                   std::string s5)
-{
-    char buffer[256];
-
-    sprintf(buffer, format, s1.c_str(), s2.c_str(), s3.c_str(),
-                            s4.c_str(), s5.c_str());
-
-    return buffer;
-}
-
-std::string img_format(const char *format,
-                   uint64 d,
-                   std::string s2)
-{
-    char buffer[256];
-
-    sprintf(buffer, format, d, s2.c_str());
-
-    return buffer;
-}
-
-std::string img_format(const char *format,
-                   std::string s1,
-                   uint64 d,
-                   std::string s2)
-{
-    char buffer[256];
-
-    sprintf(buffer, format, s1.c_str(), d, s2.c_str());
-
-    return buffer;
-}
-
-std::string img_format(const char *format,
-                   std::string s1,
-                   std::string s2,
-                   uint64 d)
-{
-    char buffer[256];
-
-    sprintf(buffer, format, s1.c_str(), s2.c_str(), d);
-
-    return buffer;
-}
-
 
-std::string to_string(img_address a)
+static char *to_string(img_address a)
 {
-    char buffer[256];
-    sprintf(buffer, "0x%" PRIx64, a);
-    return buffer;
+    return g_strdup_printf("0x%" PRIx64, a);
 }
 
 
@@ -597,7 +493,7 @@ static uint64 encode_lsb_from_pos_and_size(uint64 d)
 }
 
 
-static std::string GPR(uint64 reg)
+static const char *GPR(uint64 reg)
 {
     static const char *gpr_reg[32] = {
         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
@@ -615,21 +511,26 @@ static std::string GPR(uint64 reg)
 }
 
 
-static std::string save_restore_list(uint64 rt, uint64 count, uint64 gp)
+static char *save_restore_list(uint64 rt, uint64 count, uint64 gp)
 {
-    std::string str;
+    /*
+     * Currently, this file compiles as a cpp file, so the explicit cast here
+     * is necessary. Later, the cast will be removed.
+     */
+    char *str = (char *)g_malloc(200);
+    str[0] = '\0';
 
     for (uint64 counter = 0; counter != count; counter++) {
         bool use_gp = gp && (counter == count - 1);
         uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
-        str += img_format(",%s", GPR(this_rt));
+        strcat(str, img_format(",%s", GPR(this_rt)));
     }
 
     return str;
 }
 
 
-static std::string FPR(uint64 reg)
+static const char *FPR(uint64 reg)
 {
     static const char *fpr_reg[32] = {
         "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
@@ -647,7 +548,7 @@ static std::string FPR(uint64 reg)
 }
 
 
-static std::string AC(uint64 reg)
+static const char *AC(uint64 reg)
 {
     static const char *ac_reg[4] = {
         "ac0",  "ac1",  "ac2",  "ac3"
@@ -662,26 +563,26 @@ static std::string AC(uint64 reg)
 }
 
 
-static std::string IMMEDIATE(uint64 value)
+static char *IMMEDIATE(uint64 value)
 {
     return img_format("0x%" PRIx64, value);
 }
 
 
-static std::string IMMEDIATE(int64 value)
+static char *IMMEDIATE(int64 value)
 {
     return img_format("%" PRId64, value);
 }
 
 
-static std::string CPR(uint64 reg)
+static char *CPR(uint64 reg)
 {
     /* needs more work */
     return img_format("CP%" PRIu64, reg);
 }
 
 
-static std::string ADDRESS(uint64 value, int instruction_size, img_address m_pc)
+static char *ADDRESS(uint64 value, int instruction_size, img_address m_pc)
 {
     /* token for string replace */
     img_address address = m_pc + value + instruction_size;
@@ -716,7 +617,7 @@ static uint64 extract_op_code_value(const uint16 *data, int size)
  *      instruction size    - negative is error
  *      disassembly string  - on error will constain error string
  */
-static int Disassemble(const uint16 *data, std::string & dis,
+static int Disassemble(const uint16 *data, char *dis,
                        TABLE_ENTRY_TYPE & type, const Pool *table,
                        int table_size, img_address m_pc)
 {
@@ -746,25 +647,26 @@ static int Disassemble(const uint16 *data, std::string & dis,
                                  * an ASE attribute and the requested version
                                  * not having that attribute
                                  */
-                                dis = "ASE attribute mismatch";
+                                strcpy(dis, "ASE attribute mismatch");
                                 return -5;
                             }
                             disassembly_function dis_fn = table[i].disassembly;
                             if (dis_fn == 0) {
-                                dis = "disassembler failure - bad table entry";
+                                strcpy(dis,
+                                "disassembler failure - bad table entry");
                                 return -6;
                             }
                             type = table[i].type;
-                            dis = dis_fn(op_code, m_pc);
+                            strcpy(dis, dis_fn(op_code, m_pc));
                             return table[i].instructions_size;
                         } else {
-                            dis = "reserved instruction";
+                            strcpy(dis, "reserved instruction");
                             return -2;
                         }
                     }
                     catch (std::runtime_error & e)
                     {
-                        dis = e.what();
+                        strcpy(dis, e.what());
                         return -3;          /* runtime error */
                     }
                 }
@@ -773,11 +675,11 @@ static int Disassemble(const uint16 *data, std::string & dis,
     }
     catch (std::exception & e)
     {
-        dis = e.what();
+        strcpy(dis, e.what());
         return -4;          /* runtime error */
     }
 
-    dis = "failed to disassemble";
+    strcpy(dis, "failed to disassemble");
     return -1;      /* failed to disassemble        */
 }
 
@@ -1710,13 +1612,13 @@ static bool SLTU_cond(uint64 instruction)
  *               fs -----
  *                    fd -----
  */
-static std::string ABS_D(uint64 instruction, img_address m_pc)
+static char *ABS_D(uint64 instruction, img_address m_pc)
 {
     uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string fs = FPR(copy(fs_value));
-    std::string fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *fd = FPR(copy(fd_value));
 
     return img_format("ABS.D %s, %s", fd, fs);
 }
@@ -1732,13 +1634,13 @@ static std::string ABS_D(uint64 instruction, img_address m_pc)
  *               fd -----
  *                    fs -----
  */
-static std::string ABS_S(uint64 instruction, img_address m_pc)
+static char *ABS_S(uint64 instruction, img_address m_pc)
 {
     uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string fs = FPR(copy(fs_value));
-    std::string fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *fd = FPR(copy(fd_value));
 
     return img_format("ABS.S %s, %s", fd, fs);
 }
@@ -1754,13 +1656,13 @@ static std::string ABS_S(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ABSQ_S_PH(uint64 instruction, img_address m_pc)
+static char *ABSQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("ABSQ_S.PH %s, %s", rt, rs);
 }
@@ -1776,13 +1678,13 @@ static std::string ABSQ_S_PH(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ABSQ_S_QB(uint64 instruction, img_address m_pc)
+static char *ABSQ_S_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("ABSQ_S.QB %s, %s", rt, rs);
 }
@@ -1798,13 +1700,13 @@ static std::string ABSQ_S_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ABSQ_S_W(uint64 instruction, img_address m_pc)
+static char *ABSQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("ABSQ_S.W %s, %s", rt, rs);
 }
@@ -1819,15 +1721,15 @@ static std::string ABSQ_S_W(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ACLR(uint64 instruction, img_address m_pc)
+static char *ACLR(uint64 instruction, img_address m_pc)
 {
     uint64 bit_value = extract_bit_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string bit = IMMEDIATE(copy(bit_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *bit = IMMEDIATE(copy(bit_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("ACLR %s, %s(%s)", bit, s, rs);
 }
@@ -1842,15 +1744,15 @@ static std::string ACLR(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ADD(uint64 instruction, img_address m_pc)
+static char *ADD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADD %s, %s, %s", rd, rs, rt);
 }
@@ -1867,15 +1769,15 @@ static std::string ADD(uint64 instruction, img_address m_pc)
  *               fs -----
  *                    fd -----
  */
-static std::string ADD_D(uint64 instruction, img_address m_pc)
+static char *ADD_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string fd = FPR(copy(fd_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *fd = FPR(copy(fd_value));
 
     return img_format("ADD.D %s, %s, %s", fd, fs, ft);
 }
@@ -1892,15 +1794,15 @@ static std::string ADD_D(uint64 instruction, img_address m_pc)
  *               fs -----
  *                    fd -----
  */
-static std::string ADD_S(uint64 instruction, img_address m_pc)
+static char *ADD_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string fd = FPR(copy(fd_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *fd = FPR(copy(fd_value));
 
     return img_format("ADD.S %s, %s, %s", fd, fs, ft);
 }
@@ -1915,15 +1817,15 @@ static std::string ADD_S(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ADDIU_32_(uint64 instruction, img_address m_pc)
+static char *ADDIU_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_15_to_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt, rs, u);
 }
@@ -1938,13 +1840,13 @@ static std::string ADDIU_32_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ADDIU_48_(uint64 instruction, img_address m_pc)
+static char *ADDIU_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
 
     return img_format("ADDIU %s, %s", rt, s);
 }
@@ -1959,13 +1861,13 @@ static std::string ADDIU_48_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ADDIU_GP48_(uint64 instruction, img_address m_pc)
+static char *ADDIU_GP48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, s);
 }
@@ -1980,13 +1882,13 @@ static std::string ADDIU_GP48_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ADDIU_GP_B_(uint64 instruction, img_address m_pc)
+static char *ADDIU_GP_B_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, u);
 }
@@ -2001,13 +1903,13 @@ static std::string ADDIU_GP_B_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ADDIU_GP_W_(uint64 instruction, img_address m_pc)
+static char *ADDIU_GP_W_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, u);
 }
@@ -2022,15 +1924,15 @@ static std::string ADDIU_GP_W_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ADDIU_NEG_(uint64 instruction, img_address m_pc)
+static char *ADDIU_NEG_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string u = IMMEDIATE(neg_copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *u = IMMEDIATE(neg_copy(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt, rs, u);
 }
@@ -2045,13 +1947,13 @@ static std::string ADDIU_NEG_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ADDIU_R1_SP_(uint64 instruction, img_address m_pc)
+static char *ADDIU_R1_SP_(uint64 instruction, img_address m_pc)
 {
     uint64 u_value = extract_u_5_4_3_2_1_0__s2(instruction);
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt3, 29, u);
 }
@@ -2066,15 +1968,15 @@ static std::string ADDIU_R1_SP_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string ADDIU_R2_(uint64 instruction, img_address m_pc)
+static char *ADDIU_R2_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_2_1_0__s2(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt3, rs3, u);
 }
@@ -2088,13 +1990,13 @@ static std::string ADDIU_R2_(uint64 instruction, img_address m_pc)
  *     rt -----
  *           s - ---
  */
-static std::string ADDIU_RS5_(uint64 instruction, img_address m_pc)
+static char *ADDIU_RS5_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     int64 s_value = extract_s__se3_4_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
 
     return img_format("ADDIU %s, %s", rt, s);
 }
@@ -2110,13 +2012,13 @@ static std::string ADDIU_RS5_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDIUPC_32_(uint64 instruction, img_address m_pc)
+static char *ADDIUPC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("ADDIUPC %s, %s", rt, s);
 }
@@ -2132,13 +2034,13 @@ static std::string ADDIUPC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDIUPC_48_(uint64 instruction, img_address m_pc)
+static char *ADDIUPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("ADDIUPC %s, %s", rt, s);
 }
@@ -2154,15 +2056,15 @@ static std::string ADDIUPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDQ_PH(uint64 instruction, img_address m_pc)
+static char *ADDQ_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDQ.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2179,15 +2081,15 @@ static std::string ADDQ_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDQ_S_PH(uint64 instruction, img_address m_pc)
+static char *ADDQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2203,15 +2105,15 @@ static std::string ADDQ_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDQ_S_W(uint64 instruction, img_address m_pc)
+static char *ADDQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
 }
@@ -2228,15 +2130,15 @@ static std::string ADDQ_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDQH_PH(uint64 instruction, img_address m_pc)
+static char *ADDQH_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDQH.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2253,15 +2155,15 @@ static std::string ADDQH_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDQH_R_PH(uint64 instruction, img_address m_pc)
+static char *ADDQH_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2278,15 +2180,15 @@ static std::string ADDQH_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDQH_R_W(uint64 instruction, img_address m_pc)
+static char *ADDQH_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
 }
@@ -2303,15 +2205,15 @@ static std::string ADDQH_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDQH_W(uint64 instruction, img_address m_pc)
+static char *ADDQH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDQH.W %s, %s, %s", rd, rs, rt);
 }
@@ -2327,15 +2229,15 @@ static std::string ADDQH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDSC(uint64 instruction, img_address m_pc)
+static char *ADDSC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDSC %s, %s, %s", rd, rs, rt);
 }
@@ -2350,15 +2252,15 @@ static std::string ADDSC(uint64 instruction, img_address m_pc)
  *       rs3 ---
  *          rd3 ---
  */
-static std::string ADDU_16_(uint64 instruction, img_address m_pc)
+static char *ADDU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 rd3_value = extract_rd3_3_2_1(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rd3 = GPR(decode_gpr_gpr3(rd3_value));
 
     return img_format("ADDU %s, %s, %s", rd3, rs3, rt3);
 }
@@ -2374,15 +2276,15 @@ static std::string ADDU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDU_32_(uint64 instruction, img_address m_pc)
+static char *ADDU_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDU %s, %s, %s", rd, rs, rt);
 }
@@ -2398,13 +2300,13 @@ static std::string ADDU_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDU_4X4_(uint64 instruction, img_address m_pc)
+static char *ADDU_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
 
-    std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
-    std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
+    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
+    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value));
 
     return img_format("ADDU %s, %s", rs4, rt4);
 }
@@ -2420,15 +2322,15 @@ static std::string ADDU_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDU_PH(uint64 instruction, img_address m_pc)
+static char *ADDU_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDU.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2444,15 +2346,15 @@ static std::string ADDU_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDU_QB(uint64 instruction, img_address m_pc)
+static char *ADDU_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDU.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2469,15 +2371,15 @@ static std::string ADDU_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDU_S_PH(uint64 instruction, img_address m_pc)
+static char *ADDU_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2493,15 +2395,15 @@ static std::string ADDU_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDU_S_QB(uint64 instruction, img_address m_pc)
+static char *ADDU_S_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2518,15 +2420,15 @@ static std::string ADDU_S_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDUH_QB(uint64 instruction, img_address m_pc)
+static char *ADDUH_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDUH.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2543,15 +2445,15 @@ static std::string ADDUH_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDUH_R_QB(uint64 instruction, img_address m_pc)
+static char *ADDUH_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2566,15 +2468,15 @@ static std::string ADDUH_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ADDWC(uint64 instruction, img_address m_pc)
+static char *ADDWC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ADDWC %s, %s, %s", rd, rs, rt);
 }
@@ -2590,13 +2492,13 @@ static std::string ADDWC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ALUIPC(uint64 instruction, img_address m_pc)
+static char *ALUIPC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
 }
@@ -2611,13 +2513,13 @@ static std::string ALUIPC(uint64 instruction, img_address m_pc)
  *       rs3 ---
  *           eu ----
  */
-static std::string AND_16_(uint64 instruction, img_address m_pc)
+static char *AND_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("AND %s, %s", rs3, rt3);
 }
@@ -2633,15 +2535,15 @@ static std::string AND_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string AND_32_(uint64 instruction, img_address m_pc)
+static char *AND_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("AND %s, %s, %s", rd, rs, rt);
 }
@@ -2656,15 +2558,15 @@ static std::string AND_32_(uint64 instruction, img_address m_pc)
  *       rs3 ---
  *           eu ----
  */
-static std::string ANDI_16_(uint64 instruction, img_address m_pc)
+static char *ANDI_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 eu_value = extract_eu_3_2_1_0(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    std::string eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    char *eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
 
     return img_format("ANDI %s, %s, %s", rt3, rs3, eu);
 }
@@ -2680,15 +2582,15 @@ static std::string ANDI_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ANDI_32_(uint64 instruction, img_address m_pc)
+static char *ANDI_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ANDI %s, %s, %s", rt, rs, u);
 }
@@ -2704,15 +2606,15 @@ static std::string ANDI_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string APPEND(uint64 instruction, img_address m_pc)
+static char *APPEND(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("APPEND %s, %s, %s", rt, rs, sa);
 }
@@ -2728,15 +2630,15 @@ static std::string APPEND(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ASET(uint64 instruction, img_address m_pc)
+static char *ASET(uint64 instruction, img_address m_pc)
 {
     uint64 bit_value = extract_bit_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string bit = IMMEDIATE(copy(bit_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *bit = IMMEDIATE(copy(bit_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("ASET %s, %s(%s)", bit, s, rs);
 }
@@ -2752,11 +2654,11 @@ static std::string ASET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BALC_16_(uint64 instruction, img_address m_pc)
+static char *BALC_16_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
 
-    std::string s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BALC %s", s);
 }
@@ -2772,11 +2674,11 @@ static std::string BALC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BALC_32_(uint64 instruction, img_address m_pc)
+static char *BALC_32_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
 
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BALC %s", s);
 }
@@ -2792,13 +2694,13 @@ static std::string BALC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BALRSC(uint64 instruction, img_address m_pc)
+static char *BALRSC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("BALRSC %s, %s", rt, rs);
 }
@@ -2814,15 +2716,15 @@ static std::string BALRSC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BBEQZC(uint64 instruction, img_address m_pc)
+static char *BBEQZC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string bit = IMMEDIATE(copy(bit_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *bit = IMMEDIATE(copy(bit_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BBEQZC %s, %s, %s", rt, bit, s);
 }
@@ -2838,15 +2740,15 @@ static std::string BBEQZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BBNEZC(uint64 instruction, img_address m_pc)
+static char *BBNEZC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string bit = IMMEDIATE(copy(bit_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *bit = IMMEDIATE(copy(bit_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BBNEZC %s, %s, %s", rt, bit, s);
 }
@@ -2862,11 +2764,11 @@ static std::string BBNEZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BC_16_(uint64 instruction, img_address m_pc)
+static char *BC_16_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
 
-    std::string s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BC %s", s);
 }
@@ -2882,11 +2784,11 @@ static std::string BC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BC_32_(uint64 instruction, img_address m_pc)
+static char *BC_32_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
 
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC %s", s);
 }
@@ -2902,13 +2804,13 @@ static std::string BC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BC1EQZC(uint64 instruction, img_address m_pc)
+static char *BC1EQZC(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *ft = FPR(copy(ft_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC1EQZC %s, %s", ft, s);
 }
@@ -2924,13 +2826,13 @@ static std::string BC1EQZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BC1NEZC(uint64 instruction, img_address m_pc)
+static char *BC1NEZC(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *ft = FPR(copy(ft_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC1NEZC %s, %s", ft, s);
 }
@@ -2946,13 +2848,13 @@ static std::string BC1NEZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BC2EQZC(uint64 instruction, img_address m_pc)
+static char *BC2EQZC(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string ct = CPR(copy(ct_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    char *ct = CPR(copy(ct_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC2EQZC %s, %s", ct, s);
 }
@@ -2968,13 +2870,13 @@ static std::string BC2EQZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BC2NEZC(uint64 instruction, img_address m_pc)
+static char *BC2NEZC(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string ct = CPR(copy(ct_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    char *ct = CPR(copy(ct_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC2NEZC %s, %s", ct, s);
 }
@@ -2990,15 +2892,15 @@ static std::string BC2NEZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BEQC_16_(uint64 instruction, img_address m_pc)
+static char *BEQC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_3_2_1_0__s1(instruction);
 
-    std::string rs3 = GPR(encode_rs3_and_check_rs3_lt_rt3(rs3_value));
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
+    const char *rs3 = GPR(encode_rs3_and_check_rs3_lt_rt3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
 
     return img_format("BEQC %s, %s, %s", rs3, rt3, u);
 }
@@ -3014,15 +2916,15 @@ static std::string BEQC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BEQC_32_(uint64 instruction, img_address m_pc)
+static char *BEQC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BEQC %s, %s, %s", rs, rt, s);
 }
@@ -3038,15 +2940,15 @@ static std::string BEQC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BEQIC(uint64 instruction, img_address m_pc)
+static char *BEQIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BEQIC %s, %s, %s", rt, u, s);
 }
@@ -3062,13 +2964,13 @@ static std::string BEQIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BEQZC_16_(uint64 instruction, img_address m_pc)
+static char *BEQZC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BEQZC %s, %s", rt3, s);
 }
@@ -3084,15 +2986,15 @@ static std::string BEQZC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BGEC(uint64 instruction, img_address m_pc)
+static char *BGEC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEC %s, %s, %s", rs, rt, s);
 }
@@ -3108,15 +3010,15 @@ static std::string BGEC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BGEIC(uint64 instruction, img_address m_pc)
+static char *BGEIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEIC %s, %s, %s", rt, u, s);
 }
@@ -3132,15 +3034,15 @@ static std::string BGEIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BGEIUC(uint64 instruction, img_address m_pc)
+static char *BGEIUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEIUC %s, %s, %s", rt, u, s);
 }
@@ -3156,15 +3058,15 @@ static std::string BGEIUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BGEUC(uint64 instruction, img_address m_pc)
+static char *BGEUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEUC %s, %s, %s", rs, rt, s);
 }
@@ -3180,15 +3082,15 @@ static std::string BGEUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BLTC(uint64 instruction, img_address m_pc)
+static char *BLTC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTC %s, %s, %s", rs, rt, s);
 }
@@ -3204,15 +3106,15 @@ static std::string BLTC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BLTIC(uint64 instruction, img_address m_pc)
+static char *BLTIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTIC %s, %s, %s", rt, u, s);
 }
@@ -3228,15 +3130,15 @@ static std::string BLTIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BLTIUC(uint64 instruction, img_address m_pc)
+static char *BLTIUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTIUC %s, %s, %s", rt, u, s);
 }
@@ -3252,15 +3154,15 @@ static std::string BLTIUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BLTUC(uint64 instruction, img_address m_pc)
+static char *BLTUC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTUC %s, %s, %s", rs, rt, s);
 }
@@ -3276,15 +3178,15 @@ static std::string BLTUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BNEC_16_(uint64 instruction, img_address m_pc)
+static char *BNEC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_3_2_1_0__s1(instruction);
 
-    std::string rs3 = GPR(encode_rs3_and_check_rs3_ge_rt3(rs3_value));
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
+    const char *rs3 = GPR(encode_rs3_and_check_rs3_ge_rt3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
 
     return img_format("BNEC %s, %s, %s", rs3, rt3, u);
 }
@@ -3300,15 +3202,15 @@ static std::string BNEC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BNEC_32_(uint64 instruction, img_address m_pc)
+static char *BNEC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BNEC %s, %s, %s", rs, rt, s);
 }
@@ -3324,15 +3226,15 @@ static std::string BNEC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BNEIC(uint64 instruction, img_address m_pc)
+static char *BNEIC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BNEIC %s, %s, %s", rt, u, s);
 }
@@ -3348,13 +3250,13 @@ static std::string BNEIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BNEZC_16_(uint64 instruction, img_address m_pc)
+static char *BNEZC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BNEZC %s, %s", rt3, s);
 }
@@ -3370,11 +3272,11 @@ static std::string BNEZC_16_(uint64 instruction, img_address m_pc)
  *            s[13:1] -------------
  *                           s[14] -
  */
-static std::string BPOSGE32C(uint64 instruction, img_address m_pc)
+static char *BPOSGE32C(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BPOSGE32C %s", s);
 }
@@ -3390,11 +3292,11 @@ static std::string BPOSGE32C(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BREAK_16_(uint64 instruction, img_address m_pc)
+static char *BREAK_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
-    std::string code = IMMEDIATE(copy(code_value));
+    char *code = IMMEDIATE(copy(code_value));
 
     return img_format("BREAK %s", code);
 }
@@ -3410,11 +3312,11 @@ static std::string BREAK_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BREAK_32_(uint64 instruction, img_address m_pc)
+static char *BREAK_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
-    std::string code = IMMEDIATE(copy(code_value));
+    char *code = IMMEDIATE(copy(code_value));
 
     return img_format("BREAK %s", code);
 }
@@ -3430,11 +3332,11 @@ static std::string BREAK_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string BRSC(uint64 instruction, img_address m_pc)
+static char *BRSC(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rs = GPR(copy(rs_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("BRSC %s", rs);
 }
@@ -3450,15 +3352,15 @@ static std::string BRSC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CACHE(uint64 instruction, img_address m_pc)
+static char *CACHE(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string op = IMMEDIATE(copy(op_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *op = IMMEDIATE(copy(op_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("CACHE %s, %s(%s)", op, s, rs);
 }
@@ -3474,15 +3376,15 @@ static std::string CACHE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CACHEE(uint64 instruction, img_address m_pc)
+static char *CACHEE(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string op = IMMEDIATE(copy(op_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *op = IMMEDIATE(copy(op_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("CACHEE %s, %s(%s)", op, s, rs);
 }
@@ -3498,13 +3400,13 @@ static std::string CACHEE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CEIL_L_D(uint64 instruction, img_address m_pc)
+static char *CEIL_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CEIL.L.D %s, %s", ft, fs);
 }
@@ -3520,13 +3422,13 @@ static std::string CEIL_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CEIL_L_S(uint64 instruction, img_address m_pc)
+static char *CEIL_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CEIL.L.S %s, %s", ft, fs);
 }
@@ -3542,13 +3444,13 @@ static std::string CEIL_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CEIL_W_D(uint64 instruction, img_address m_pc)
+static char *CEIL_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CEIL.W.D %s, %s", ft, fs);
 }
@@ -3564,13 +3466,13 @@ static std::string CEIL_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CEIL_W_S(uint64 instruction, img_address m_pc)
+static char *CEIL_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CEIL.W.S %s, %s", ft, fs);
 }
@@ -3586,13 +3488,13 @@ static std::string CEIL_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CFC1(uint64 instruction, img_address m_pc)
+static char *CFC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *cs = CPR(copy(cs_value));
 
     return img_format("CFC1 %s, %s", rt, cs);
 }
@@ -3608,13 +3510,13 @@ static std::string CFC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CFC2(uint64 instruction, img_address m_pc)
+static char *CFC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *cs = CPR(copy(cs_value));
 
     return img_format("CFC2 %s, %s", rt, cs);
 }
@@ -3630,13 +3532,13 @@ static std::string CFC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CLASS_D(uint64 instruction, img_address m_pc)
+static char *CLASS_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CLASS.D %s, %s", ft, fs);
 }
@@ -3652,13 +3554,13 @@ static std::string CLASS_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CLASS_S(uint64 instruction, img_address m_pc)
+static char *CLASS_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CLASS.S %s, %s", ft, fs);
 }
@@ -3674,13 +3576,13 @@ static std::string CLASS_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CLO(uint64 instruction, img_address m_pc)
+static char *CLO(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("CLO %s, %s", rt, rs);
 }
@@ -3696,13 +3598,13 @@ static std::string CLO(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CLZ(uint64 instruction, img_address m_pc)
+static char *CLZ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("CLZ %s, %s", rt, rs);
 }
@@ -3718,15 +3620,15 @@ static std::string CLZ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_AF_D(uint64 instruction, img_address m_pc)
+static char *CMP_AF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.AF.D %s, %s, %s", fd, fs, ft);
 }
@@ -3742,15 +3644,15 @@ static std::string CMP_AF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_AF_S(uint64 instruction, img_address m_pc)
+static char *CMP_AF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.AF.S %s, %s, %s", fd, fs, ft);
 }
@@ -3766,15 +3668,15 @@ static std::string CMP_AF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_EQ_D(uint64 instruction, img_address m_pc)
+static char *CMP_EQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -3789,13 +3691,13 @@ static std::string CMP_EQ_D(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string CMP_EQ_PH(uint64 instruction, img_address m_pc)
+static char *CMP_EQ_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMP.EQ.PH %s, %s", rs, rt);
 }
@@ -3811,15 +3713,15 @@ static std::string CMP_EQ_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_EQ_S(uint64 instruction, img_address m_pc)
+static char *CMP_EQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -3835,15 +3737,15 @@ static std::string CMP_EQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_LE_D(uint64 instruction, img_address m_pc)
+static char *CMP_LE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.LE.D %s, %s, %s", fd, fs, ft);
 }
@@ -3858,13 +3760,13 @@ static std::string CMP_LE_D(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string CMP_LE_PH(uint64 instruction, img_address m_pc)
+static char *CMP_LE_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMP.LE.PH %s, %s", rs, rt);
 }
@@ -3880,15 +3782,15 @@ static std::string CMP_LE_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_LE_S(uint64 instruction, img_address m_pc)
+static char *CMP_LE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.LE.S %s, %s, %s", fd, fs, ft);
 }
@@ -3904,15 +3806,15 @@ static std::string CMP_LE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_LT_D(uint64 instruction, img_address m_pc)
+static char *CMP_LT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.LT.D %s, %s, %s", fd, fs, ft);
 }
@@ -3927,13 +3829,13 @@ static std::string CMP_LT_D(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string CMP_LT_PH(uint64 instruction, img_address m_pc)
+static char *CMP_LT_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMP.LT.PH %s, %s", rs, rt);
 }
@@ -3949,15 +3851,15 @@ static std::string CMP_LT_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_LT_S(uint64 instruction, img_address m_pc)
+static char *CMP_LT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.LT.S %s, %s, %s", fd, fs, ft);
 }
@@ -3973,15 +3875,15 @@ static std::string CMP_LT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_NE_D(uint64 instruction, img_address m_pc)
+static char *CMP_NE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.NE.D %s, %s, %s", fd, fs, ft);
 }
@@ -3997,15 +3899,15 @@ static std::string CMP_NE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_NE_S(uint64 instruction, img_address m_pc)
+static char *CMP_NE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.NE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4021,15 +3923,15 @@ static std::string CMP_NE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_OR_D(uint64 instruction, img_address m_pc)
+static char *CMP_OR_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.OR.D %s, %s, %s", fd, fs, ft);
 }
@@ -4045,15 +3947,15 @@ static std::string CMP_OR_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_OR_S(uint64 instruction, img_address m_pc)
+static char *CMP_OR_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.OR.S %s, %s, %s", fd, fs, ft);
 }
@@ -4069,15 +3971,15 @@ static std::string CMP_OR_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SAF_D(uint64 instruction, img_address m_pc)
+static char *CMP_SAF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
 }
@@ -4093,15 +3995,15 @@ static std::string CMP_SAF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SAF_S(uint64 instruction, img_address m_pc)
+static char *CMP_SAF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
 }
@@ -4117,15 +4019,15 @@ static std::string CMP_SAF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SEQ_D(uint64 instruction, img_address m_pc)
+static char *CMP_SEQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -4141,15 +4043,15 @@ static std::string CMP_SEQ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SEQ_S(uint64 instruction, img_address m_pc)
+static char *CMP_SEQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -4165,15 +4067,15 @@ static std::string CMP_SEQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SLE_D(uint64 instruction, img_address m_pc)
+static char *CMP_SLE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4189,15 +4091,15 @@ static std::string CMP_SLE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SLE_S(uint64 instruction, img_address m_pc)
+static char *CMP_SLE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4213,15 +4115,15 @@ static std::string CMP_SLE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SLT_D(uint64 instruction, img_address m_pc)
+static char *CMP_SLT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
 }
@@ -4237,15 +4139,15 @@ static std::string CMP_SLT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SLT_S(uint64 instruction, img_address m_pc)
+static char *CMP_SLT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
 }
@@ -4261,15 +4163,15 @@ static std::string CMP_SLT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SNE_D(uint64 instruction, img_address m_pc)
+static char *CMP_SNE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4285,15 +4187,15 @@ static std::string CMP_SNE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SNE_S(uint64 instruction, img_address m_pc)
+static char *CMP_SNE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4309,15 +4211,15 @@ static std::string CMP_SNE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SOR_D(uint64 instruction, img_address m_pc)
+static char *CMP_SOR_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
 }
@@ -4333,15 +4235,15 @@ static std::string CMP_SOR_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SOR_S(uint64 instruction, img_address m_pc)
+static char *CMP_SOR_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
 }
@@ -4357,15 +4259,15 @@ static std::string CMP_SOR_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SUEQ_D(uint64 instruction, img_address m_pc)
+static char *CMP_SUEQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -4381,15 +4283,15 @@ static std::string CMP_SUEQ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SUEQ_S(uint64 instruction, img_address m_pc)
+static char *CMP_SUEQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -4405,15 +4307,15 @@ static std::string CMP_SUEQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SULE_D(uint64 instruction, img_address m_pc)
+static char *CMP_SULE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4429,15 +4331,15 @@ static std::string CMP_SULE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SULE_S(uint64 instruction, img_address m_pc)
+static char *CMP_SULE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4453,15 +4355,15 @@ static std::string CMP_SULE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SULT_D(uint64 instruction, img_address m_pc)
+static char *CMP_SULT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
 }
@@ -4477,15 +4379,15 @@ static std::string CMP_SULT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SULT_S(uint64 instruction, img_address m_pc)
+static char *CMP_SULT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
 }
@@ -4501,15 +4403,15 @@ static std::string CMP_SULT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SUN_D(uint64 instruction, img_address m_pc)
+static char *CMP_SUN_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
 }
@@ -4525,15 +4427,15 @@ static std::string CMP_SUN_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SUNE_D(uint64 instruction, img_address m_pc)
+static char *CMP_SUNE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4549,15 +4451,15 @@ static std::string CMP_SUNE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SUNE_S(uint64 instruction, img_address m_pc)
+static char *CMP_SUNE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4573,15 +4475,15 @@ static std::string CMP_SUNE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_SUN_S(uint64 instruction, img_address m_pc)
+static char *CMP_SUN_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
 }
@@ -4597,15 +4499,15 @@ static std::string CMP_SUN_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_UEQ_D(uint64 instruction, img_address m_pc)
+static char *CMP_UEQ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -4621,15 +4523,15 @@ static std::string CMP_UEQ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_UEQ_S(uint64 instruction, img_address m_pc)
+static char *CMP_UEQ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -4645,15 +4547,15 @@ static std::string CMP_UEQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_ULE_D(uint64 instruction, img_address m_pc)
+static char *CMP_ULE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4669,15 +4571,15 @@ static std::string CMP_ULE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_ULE_S(uint64 instruction, img_address m_pc)
+static char *CMP_ULE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4693,15 +4595,15 @@ static std::string CMP_ULE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_ULT_D(uint64 instruction, img_address m_pc)
+static char *CMP_ULT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
 }
@@ -4717,15 +4619,15 @@ static std::string CMP_ULT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_ULT_S(uint64 instruction, img_address m_pc)
+static char *CMP_ULT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
 }
@@ -4741,15 +4643,15 @@ static std::string CMP_ULT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_UN_D(uint64 instruction, img_address m_pc)
+static char *CMP_UN_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.UN.D %s, %s, %s", fd, fs, ft);
 }
@@ -4765,15 +4667,15 @@ static std::string CMP_UN_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_UNE_D(uint64 instruction, img_address m_pc)
+static char *CMP_UNE_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4789,15 +4691,15 @@ static std::string CMP_UNE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_UNE_S(uint64 instruction, img_address m_pc)
+static char *CMP_UNE_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4813,15 +4715,15 @@ static std::string CMP_UNE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMP_UN_S(uint64 instruction, img_address m_pc)
+static char *CMP_UN_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("CMP.UN.S %s, %s, %s", fd, fs, ft);
 }
@@ -4838,15 +4740,15 @@ static std::string CMP_UN_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMPGDU_EQ_QB(uint64 instruction, img_address m_pc)
+static char *CMPGDU_EQ_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4863,15 +4765,15 @@ static std::string CMPGDU_EQ_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMPGDU_LE_QB(uint64 instruction, img_address m_pc)
+static char *CMPGDU_LE_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4888,15 +4790,15 @@ static std::string CMPGDU_LE_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMPGDU_LT_QB(uint64 instruction, img_address m_pc)
+static char *CMPGDU_LT_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4913,15 +4815,15 @@ static std::string CMPGDU_LT_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMPGU_EQ_QB(uint64 instruction, img_address m_pc)
+static char *CMPGU_EQ_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4938,15 +4840,15 @@ static std::string CMPGU_EQ_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMPGU_LE_QB(uint64 instruction, img_address m_pc)
+static char *CMPGU_LE_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4963,15 +4865,15 @@ static std::string CMPGU_LE_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CMPGU_LT_QB(uint64 instruction, img_address m_pc)
+static char *CMPGU_LT_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4987,13 +4889,13 @@ static std::string CMPGU_LT_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string CMPU_EQ_QB(uint64 instruction, img_address m_pc)
+static char *CMPU_EQ_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMPU.EQ.QB %s, %s", rs, rt);
 }
@@ -5009,13 +4911,13 @@ static std::string CMPU_EQ_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string CMPU_LE_QB(uint64 instruction, img_address m_pc)
+static char *CMPU_LE_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMPU.LE.QB %s, %s", rs, rt);
 }
@@ -5031,13 +4933,13 @@ static std::string CMPU_LE_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string CMPU_LT_QB(uint64 instruction, img_address m_pc)
+static char *CMPU_LT_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("CMPU.LT.QB %s, %s", rs, rt);
 }
@@ -5053,11 +4955,11 @@ static std::string CMPU_LT_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string COP2_1(uint64 instruction, img_address m_pc)
+static char *COP2_1(uint64 instruction, img_address m_pc)
 {
     uint64 cofun_value = extract_cofun_25_24_23(instruction);
 
-    std::string cofun = IMMEDIATE(copy(cofun_value));
+    char *cofun = IMMEDIATE(copy(cofun_value));
 
     return img_format("COP2_1 %s", cofun);
 }
@@ -5073,13 +4975,13 @@ static std::string COP2_1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CTC1(uint64 instruction, img_address m_pc)
+static char *CTC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *cs = CPR(copy(cs_value));
 
     return img_format("CTC1 %s, %s", rt, cs);
 }
@@ -5095,13 +4997,13 @@ static std::string CTC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CTC2(uint64 instruction, img_address m_pc)
+static char *CTC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *cs = CPR(copy(cs_value));
 
     return img_format("CTC2 %s, %s", rt, cs);
 }
@@ -5117,13 +5019,13 @@ static std::string CTC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_D_L(uint64 instruction, img_address m_pc)
+static char *CVT_D_L(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.D.L %s, %s", ft, fs);
 }
@@ -5139,13 +5041,13 @@ static std::string CVT_D_L(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_D_S(uint64 instruction, img_address m_pc)
+static char *CVT_D_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.D.S %s, %s", ft, fs);
 }
@@ -5161,13 +5063,13 @@ static std::string CVT_D_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_D_W(uint64 instruction, img_address m_pc)
+static char *CVT_D_W(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.D.W %s, %s", ft, fs);
 }
@@ -5183,13 +5085,13 @@ static std::string CVT_D_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_L_D(uint64 instruction, img_address m_pc)
+static char *CVT_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.L.D %s, %s", ft, fs);
 }
@@ -5205,13 +5107,13 @@ static std::string CVT_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_L_S(uint64 instruction, img_address m_pc)
+static char *CVT_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.L.S %s, %s", ft, fs);
 }
@@ -5227,13 +5129,13 @@ static std::string CVT_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_S_D(uint64 instruction, img_address m_pc)
+static char *CVT_S_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.S.D %s, %s", ft, fs);
 }
@@ -5249,13 +5151,13 @@ static std::string CVT_S_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_S_L(uint64 instruction, img_address m_pc)
+static char *CVT_S_L(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.S.L %s, %s", ft, fs);
 }
@@ -5271,13 +5173,13 @@ static std::string CVT_S_L(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_S_PL(uint64 instruction, img_address m_pc)
+static char *CVT_S_PL(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.S.PL %s, %s", ft, fs);
 }
@@ -5293,13 +5195,13 @@ static std::string CVT_S_PL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_S_PU(uint64 instruction, img_address m_pc)
+static char *CVT_S_PU(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.S.PU %s, %s", ft, fs);
 }
@@ -5315,13 +5217,13 @@ static std::string CVT_S_PU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_S_W(uint64 instruction, img_address m_pc)
+static char *CVT_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.S.W %s, %s", ft, fs);
 }
@@ -5337,13 +5239,13 @@ static std::string CVT_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_W_D(uint64 instruction, img_address m_pc)
+static char *CVT_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.W.D %s, %s", ft, fs);
 }
@@ -5359,13 +5261,13 @@ static std::string CVT_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string CVT_W_S(uint64 instruction, img_address m_pc)
+static char *CVT_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("CVT.W.S %s, %s", ft, fs);
 }
@@ -5381,13 +5283,13 @@ static std::string CVT_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DADDIU_48_(uint64 instruction, img_address m_pc)
+static char *DADDIU_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
 
     return img_format("DADDIU %s, %s", rt, s);
 }
@@ -5403,15 +5305,15 @@ static std::string DADDIU_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DADDIU_NEG_(uint64 instruction, img_address m_pc)
+static char *DADDIU_NEG_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string u = IMMEDIATE(neg_copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *u = IMMEDIATE(neg_copy(u_value));
 
     return img_format("DADDIU %s, %s, %s", rt, rs, u);
 }
@@ -5427,15 +5329,15 @@ static std::string DADDIU_NEG_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DADDIU_U12_(uint64 instruction, img_address m_pc)
+static char *DADDIU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("DADDIU %s, %s, %s", rt, rs, u);
 }
@@ -5451,15 +5353,15 @@ static std::string DADDIU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DADD(uint64 instruction, img_address m_pc)
+static char *DADD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DADD %s, %s, %s", rd, rs, rt);
 }
@@ -5475,15 +5377,15 @@ static std::string DADD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DADDU(uint64 instruction, img_address m_pc)
+static char *DADDU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DADDU %s, %s, %s", rd, rs, rt);
 }
@@ -5499,13 +5401,13 @@ static std::string DADDU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DCLO(uint64 instruction, img_address m_pc)
+static char *DCLO(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("DCLO %s, %s", rt, rs);
 }
@@ -5521,13 +5423,13 @@ static std::string DCLO(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DCLZ(uint64 instruction, img_address m_pc)
+static char *DCLZ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("DCLZ %s, %s", rt, rs);
 }
@@ -5543,15 +5445,15 @@ static std::string DCLZ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DDIV(uint64 instruction, img_address m_pc)
+static char *DDIV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DDIV %s, %s, %s", rd, rs, rt);
 }
@@ -5567,15 +5469,15 @@ static std::string DDIV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DDIVU(uint64 instruction, img_address m_pc)
+static char *DDIVU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DDIVU %s, %s, %s", rd, rs, rt);
 }
@@ -5591,11 +5493,11 @@ static std::string DDIVU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DERET(uint64 instruction, img_address m_pc)
+static char *DERET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "DERET ";
+    return (char *)"DERET ";
 }
 
 
@@ -5609,17 +5511,17 @@ static std::string DERET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DEXTM(uint64 instruction, img_address m_pc)
+static char *DEXTM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string lsb = IMMEDIATE(copy(lsb_value));
-    std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *lsb = IMMEDIATE(copy(lsb_value));
+    char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
     return img_format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -5635,17 +5537,17 @@ static std::string DEXTM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DEXT(uint64 instruction, img_address m_pc)
+static char *DEXT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string lsb = IMMEDIATE(copy(lsb_value));
-    std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *lsb = IMMEDIATE(copy(lsb_value));
+    char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
     return img_format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -5661,17 +5563,17 @@ static std::string DEXT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DEXTU(uint64 instruction, img_address m_pc)
+static char *DEXTU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string lsb = IMMEDIATE(copy(lsb_value));
-    std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *lsb = IMMEDIATE(copy(lsb_value));
+    char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
     return img_format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -5687,17 +5589,17 @@ static std::string DEXTU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DINSM(uint64 instruction, img_address m_pc)
+static char *DINSM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
+    char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("DINSM %s, %s, %s, %s", rt, rs, pos, size);
@@ -5715,17 +5617,17 @@ static std::string DINSM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DINS(uint64 instruction, img_address m_pc)
+static char *DINS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
+    char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("DINS %s, %s, %s, %s", rt, rs, pos, size);
@@ -5743,17 +5645,17 @@ static std::string DINS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DINSU(uint64 instruction, img_address m_pc)
+static char *DINSU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
+    char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("DINSU %s, %s, %s, %s", rt, rs, pos, size);
@@ -5771,11 +5673,11 @@ static std::string DINSU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DI(uint64 instruction, img_address m_pc)
+static char *DI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    std::string rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DI %s", rt);
 }
@@ -5791,15 +5693,15 @@ static std::string DI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DIV(uint64 instruction, img_address m_pc)
+static char *DIV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DIV %s, %s, %s", rd, rs, rt);
 }
@@ -5815,15 +5717,15 @@ static std::string DIV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DIV_D(uint64 instruction, img_address m_pc)
+static char *DIV_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("DIV.D %s, %s, %s", fd, fs, ft);
 }
@@ -5839,15 +5741,15 @@ static std::string DIV_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DIV_S(uint64 instruction, img_address m_pc)
+static char *DIV_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("DIV.S %s, %s, %s", fd, fs, ft);
 }
@@ -5863,15 +5765,15 @@ static std::string DIV_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DIVU(uint64 instruction, img_address m_pc)
+static char *DIVU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DIVU %s, %s, %s", rd, rs, rt);
 }
@@ -5887,17 +5789,17 @@ static std::string DIVU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DLSA(uint64 instruction, img_address m_pc)
+static char *DLSA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 u2_value = extract_u2_10_9(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string u2 = IMMEDIATE(copy(u2_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u2 = IMMEDIATE(copy(u2_value));
 
     return img_format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
 }
@@ -5913,13 +5815,13 @@ static std::string DLSA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DLUI_48_(uint64 instruction, img_address m_pc)
+static char *DLUI_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     uint64 u_value = extract_u_31_to_0__s32(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("DLUI %s, %s", rt, u);
 }
@@ -5935,15 +5837,15 @@ static std::string DLUI_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMFC0(uint64 instruction, img_address m_pc)
+static char *DMFC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("DMFC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -5959,13 +5861,13 @@ static std::string DMFC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMFC1(uint64 instruction, img_address m_pc)
+static char *DMFC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("DMFC1 %s, %s", rt, fs);
 }
@@ -5981,13 +5883,13 @@ static std::string DMFC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMFC2(uint64 instruction, img_address m_pc)
+static char *DMFC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *cs = CPR(copy(cs_value));
 
     return img_format("DMFC2 %s, %s", rt, cs);
 }
@@ -6003,15 +5905,15 @@ static std::string DMFC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMFGC0(uint64 instruction, img_address m_pc)
+static char *DMFGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("DMFGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -6027,15 +5929,15 @@ static std::string DMFGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMOD(uint64 instruction, img_address m_pc)
+static char *DMOD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DMOD %s, %s, %s", rd, rs, rt);
 }
@@ -6051,15 +5953,15 @@ static std::string DMOD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMODU(uint64 instruction, img_address m_pc)
+static char *DMODU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DMODU %s, %s, %s", rd, rs, rt);
 }
@@ -6075,15 +5977,15 @@ static std::string DMODU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMTC0(uint64 instruction, img_address m_pc)
+static char *DMTC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("DMTC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -6099,13 +6001,13 @@ static std::string DMTC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMTC1(uint64 instruction, img_address m_pc)
+static char *DMTC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("DMTC1 %s, %s", rt, fs);
 }
@@ -6121,13 +6023,13 @@ static std::string DMTC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMTC2(uint64 instruction, img_address m_pc)
+static char *DMTC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *cs = CPR(copy(cs_value));
 
     return img_format("DMTC2 %s, %s", rt, cs);
 }
@@ -6143,15 +6045,15 @@ static std::string DMTC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMTGC0(uint64 instruction, img_address m_pc)
+static char *DMTGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("DMTGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -6167,11 +6069,11 @@ static std::string DMTGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMT(uint64 instruction, img_address m_pc)
+static char *DMT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    std::string rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DMT %s", rt);
 }
@@ -6187,15 +6089,15 @@ static std::string DMT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMUH(uint64 instruction, img_address m_pc)
+static char *DMUH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DMUH %s, %s, %s", rd, rs, rt);
 }
@@ -6211,15 +6113,15 @@ static std::string DMUH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMUHU(uint64 instruction, img_address m_pc)
+static char *DMUHU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DMUHU %s, %s, %s", rd, rs, rt);
 }
@@ -6235,15 +6137,15 @@ static std::string DMUHU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMUL(uint64 instruction, img_address m_pc)
+static char *DMUL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DMUL %s, %s, %s", rd, rs, rt);
 }
@@ -6259,15 +6161,15 @@ static std::string DMUL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DMULU(uint64 instruction, img_address m_pc)
+static char *DMULU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DMULU %s, %s, %s", rd, rs, rt);
 }
@@ -6284,15 +6186,15 @@ static std::string DMULU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string DPA_W_PH(uint64 instruction, img_address m_pc)
+static char *DPA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6308,15 +6210,15 @@ static std::string DPA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPAQ_SA_L_W(uint64 instruction, img_address m_pc)
+static char *DPAQ_SA_L_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPAQ_SA.L.W %s, %s, %s", ac, rs, rt);
 }
@@ -6332,15 +6234,15 @@ static std::string DPAQ_SA_L_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPAQ_S_W_PH(uint64 instruction, img_address m_pc)
+static char *DPAQ_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPAQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6356,15 +6258,15 @@ static std::string DPAQ_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPAQX_SA_W_PH(uint64 instruction, img_address m_pc)
+static char *DPAQX_SA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6380,15 +6282,15 @@ static std::string DPAQX_SA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPAQX_S_W_PH(uint64 instruction, img_address m_pc)
+static char *DPAQX_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6404,15 +6306,15 @@ static std::string DPAQX_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPAU_H_QBL(uint64 instruction, img_address m_pc)
+static char *DPAU_H_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
 }
@@ -6428,15 +6330,15 @@ static std::string DPAU_H_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPAU_H_QBR(uint64 instruction, img_address m_pc)
+static char *DPAU_H_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
 }
@@ -6452,15 +6354,15 @@ static std::string DPAU_H_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPAX_W_PH(uint64 instruction, img_address m_pc)
+static char *DPAX_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6476,15 +6378,15 @@ static std::string DPAX_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPS_W_PH(uint64 instruction, img_address m_pc)
+static char *DPS_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPS.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6500,15 +6402,15 @@ static std::string DPS_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPSQ_SA_L_W(uint64 instruction, img_address m_pc)
+static char *DPSQ_SA_L_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
 }
@@ -6524,15 +6426,15 @@ static std::string DPSQ_SA_L_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPSQ_S_W_PH(uint64 instruction, img_address m_pc)
+static char *DPSQ_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6548,15 +6450,15 @@ static std::string DPSQ_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPSQX_SA_W_PH(uint64 instruction, img_address m_pc)
+static char *DPSQX_SA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6572,15 +6474,15 @@ static std::string DPSQX_SA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPSQX_S_W_PH(uint64 instruction, img_address m_pc)
+static char *DPSQX_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6596,15 +6498,15 @@ static std::string DPSQX_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPSU_H_QBL(uint64 instruction, img_address m_pc)
+static char *DPSU_H_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
 }
@@ -6620,15 +6522,15 @@ static std::string DPSU_H_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPSU_H_QBR(uint64 instruction, img_address m_pc)
+static char *DPSU_H_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
 }
@@ -6644,15 +6546,15 @@ static std::string DPSU_H_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DPSX_W_PH(uint64 instruction, img_address m_pc)
+static char *DPSX_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6668,15 +6570,15 @@ static std::string DPSX_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DROTR(uint64 instruction, img_address m_pc)
+static char *DROTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DROTR %s, %s, %s", rt, rs, shift);
 }
@@ -6692,15 +6594,15 @@ static std::string DROTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static std::string DROTR32(uint64 instruction, img_address m_pc)
+static char *DROTR32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DROTR32 %s, %s, %s", rt, rs, shift);
 }
@@ -6716,15 +6618,15 @@ static std::string DROTR32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DROTRV(uint64 instruction, img_address m_pc)
+static char *DROTRV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DROTRV %s, %s, %s", rd, rs, rt);
 }
@@ -6740,17 +6642,17 @@ static std::string DROTRV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DROTX(uint64 instruction, img_address m_pc)
+static char *DROTX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shiftx_value = extract_shiftx_11_10_9_8_7_6(instruction);
     uint64 shift_value = extract_shift_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
-    std::string shiftx = IMMEDIATE(copy(shiftx_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
+    char *shiftx = IMMEDIATE(copy(shiftx_value));
 
     return img_format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
 }
@@ -6766,15 +6668,15 @@ static std::string DROTX(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static std::string DSLL(uint64 instruction, img_address m_pc)
+static char *DSLL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSLL %s, %s, %s", rt, rs, shift);
 }
@@ -6790,15 +6692,15 @@ static std::string DSLL(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static std::string DSLL32(uint64 instruction, img_address m_pc)
+static char *DSLL32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSLL32 %s, %s, %s", rt, rs, shift);
 }
@@ -6814,15 +6716,15 @@ static std::string DSLL32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DSLLV(uint64 instruction, img_address m_pc)
+static char *DSLLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DSLLV %s, %s, %s", rd, rs, rt);
 }
@@ -6838,15 +6740,15 @@ static std::string DSLLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static std::string DSRA(uint64 instruction, img_address m_pc)
+static char *DSRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSRA %s, %s, %s", rt, rs, shift);
 }
@@ -6862,15 +6764,15 @@ static std::string DSRA(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static std::string DSRA32(uint64 instruction, img_address m_pc)
+static char *DSRA32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSRA32 %s, %s, %s", rt, rs, shift);
 }
@@ -6886,15 +6788,15 @@ static std::string DSRA32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DSRAV(uint64 instruction, img_address m_pc)
+static char *DSRAV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DSRAV %s, %s, %s", rd, rs, rt);
 }
@@ -6910,15 +6812,15 @@ static std::string DSRAV(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static std::string DSRL(uint64 instruction, img_address m_pc)
+static char *DSRL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSRL %s, %s, %s", rt, rs, shift);
 }
@@ -6934,15 +6836,15 @@ static std::string DSRL(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static std::string DSRL32(uint64 instruction, img_address m_pc)
+static char *DSRL32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSRL32 %s, %s, %s", rt, rs, shift);
 }
@@ -6958,15 +6860,15 @@ static std::string DSRL32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DSRLV(uint64 instruction, img_address m_pc)
+static char *DSRLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DSRLV %s, %s, %s", rd, rs, rt);
 }
@@ -6982,15 +6884,15 @@ static std::string DSRLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DSUB(uint64 instruction, img_address m_pc)
+static char *DSUB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DSUB %s, %s, %s", rd, rs, rt);
 }
@@ -7006,15 +6908,15 @@ static std::string DSUB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DSUBU(uint64 instruction, img_address m_pc)
+static char *DSUBU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DSUBU %s, %s, %s", rd, rs, rt);
 }
@@ -7030,11 +6932,11 @@ static std::string DSUBU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DVPE(uint64 instruction, img_address m_pc)
+static char *DVPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    std::string rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DVPE %s", rt);
 }
@@ -7050,11 +6952,11 @@ static std::string DVPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string DVP(uint64 instruction, img_address m_pc)
+static char *DVP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    std::string rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("DVP %s", rt);
 }
@@ -7070,11 +6972,11 @@ static std::string DVP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EHB(uint64 instruction, img_address m_pc)
+static char *EHB(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "EHB ";
+    return (char *)"EHB ";
 }
 
 
@@ -7088,11 +6990,11 @@ static std::string EHB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EI(uint64 instruction, img_address m_pc)
+static char *EI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    std::string rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("EI %s", rt);
 }
@@ -7108,11 +7010,11 @@ static std::string EI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EMT(uint64 instruction, img_address m_pc)
+static char *EMT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    std::string rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("EMT %s", rt);
 }
@@ -7128,11 +7030,11 @@ static std::string EMT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ERET(uint64 instruction, img_address m_pc)
+static char *ERET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "ERET ";
+    return (char *)"ERET ";
 }
 
 
@@ -7146,11 +7048,11 @@ static std::string ERET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ERETNC(uint64 instruction, img_address m_pc)
+static char *ERETNC(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "ERETNC ";
+    return (char *)"ERETNC ";
 }
 
 
@@ -7164,11 +7066,11 @@ static std::string ERETNC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EVP(uint64 instruction, img_address m_pc)
+static char *EVP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    std::string rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("EVP %s", rt);
 }
@@ -7184,11 +7086,11 @@ static std::string EVP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EVPE(uint64 instruction, img_address m_pc)
+static char *EVPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    std::string rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("EVPE %s", rt);
 }
@@ -7204,17 +7106,17 @@ static std::string EVPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EXT(uint64 instruction, img_address m_pc)
+static char *EXT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string lsb = IMMEDIATE(copy(lsb_value));
-    std::string msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *lsb = IMMEDIATE(copy(lsb_value));
+    char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
     return img_format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -7230,17 +7132,17 @@ static std::string EXT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EXTD(uint64 instruction, img_address m_pc)
+static char *EXTD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
 }
@@ -7256,17 +7158,17 @@ static std::string EXTD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EXTD32(uint64 instruction, img_address m_pc)
+static char *EXTD32(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
 }
@@ -7282,15 +7184,15 @@ static std::string EXTD32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EXTPDP(uint64 instruction, img_address m_pc)
+static char *EXTPDP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 size_value = extract_size_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string size = IMMEDIATE(copy(size_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    char *size = IMMEDIATE(copy(size_value));
 
     return img_format("EXTPDP %s, %s, %s", rt, ac, size);
 }
@@ -7306,15 +7208,15 @@ static std::string EXTPDP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EXTPDPV(uint64 instruction, img_address m_pc)
+static char *EXTPDPV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("EXTPDPV %s, %s, %s", rt, ac, rs);
 }
@@ -7330,15 +7232,15 @@ static std::string EXTPDPV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EXTP(uint64 instruction, img_address m_pc)
+static char *EXTP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 size_value = extract_size_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string size = IMMEDIATE(copy(size_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    char *size = IMMEDIATE(copy(size_value));
 
     return img_format("EXTP %s, %s, %s", rt, ac, size);
 }
@@ -7354,15 +7256,15 @@ static std::string EXTP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string EXTPV(uint64 instruction, img_address m_pc)
+static char *EXTPV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("EXTPV %s, %s, %s", rt, ac, rs);
 }
@@ -7379,15 +7281,15 @@ static std::string EXTPV(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-static std::string EXTR_RS_W(uint64 instruction, img_address m_pc)
+static char *EXTR_RS_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
 }
@@ -7404,15 +7306,15 @@ static std::string EXTR_RS_W(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-static std::string EXTR_R_W(uint64 instruction, img_address m_pc)
+static char *EXTR_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTR_R.W %s, %s, %s", rt, ac, shift);
 }
@@ -7429,15 +7331,15 @@ static std::string EXTR_R_W(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-static std::string EXTR_S_H(uint64 instruction, img_address m_pc)
+static char *EXTR_S_H(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTR_S.H %s, %s, %s", rt, ac, shift);
 }
@@ -7454,15 +7356,15 @@ static std::string EXTR_S_H(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-static std::string EXTR_W(uint64 instruction, img_address m_pc)
+static char *EXTR_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTR.W %s, %s, %s", rt, ac, shift);
 }
@@ -7479,15 +7381,15 @@ static std::string EXTR_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string EXTRV_RS_W(uint64 instruction, img_address m_pc)
+static char *EXTRV_RS_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
 }
@@ -7504,15 +7406,15 @@ static std::string EXTRV_RS_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string EXTRV_R_W(uint64 instruction, img_address m_pc)
+static char *EXTRV_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
 }
@@ -7529,15 +7431,15 @@ static std::string EXTRV_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string EXTRV_S_H(uint64 instruction, img_address m_pc)
+static char *EXTRV_S_H(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
 }
@@ -7554,15 +7456,15 @@ static std::string EXTRV_S_H(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string EXTRV_W(uint64 instruction, img_address m_pc)
+static char *EXTRV_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("EXTRV.W %s, %s, %s", rt, ac, rs);
 }
@@ -7579,17 +7481,17 @@ static std::string EXTRV_W(uint64 instruction, img_address m_pc)
  *               rd -----
  *                 shift -----
  */
-static std::string EXTW(uint64 instruction, img_address m_pc)
+static char *EXTW(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
 }
@@ -7605,13 +7507,13 @@ static std::string EXTW(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string FLOOR_L_D(uint64 instruction, img_address m_pc)
+static char *FLOOR_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("FLOOR.L.D %s, %s", ft, fs);
 }
@@ -7627,13 +7529,13 @@ static std::string FLOOR_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string FLOOR_L_S(uint64 instruction, img_address m_pc)
+static char *FLOOR_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("FLOOR.L.S %s, %s", ft, fs);
 }
@@ -7649,13 +7551,13 @@ static std::string FLOOR_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string FLOOR_W_D(uint64 instruction, img_address m_pc)
+static char *FLOOR_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("FLOOR.W.D %s, %s", ft, fs);
 }
@@ -7671,13 +7573,13 @@ static std::string FLOOR_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string FLOOR_W_S(uint64 instruction, img_address m_pc)
+static char *FLOOR_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("FLOOR.W.S %s, %s", ft, fs);
 }
@@ -7693,15 +7595,15 @@ static std::string FLOOR_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string FORK(uint64 instruction, img_address m_pc)
+static char *FORK(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("FORK %s, %s, %s", rd, rs, rt);
 }
@@ -7717,11 +7619,11 @@ static std::string FORK(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string HYPCALL(uint64 instruction, img_address m_pc)
+static char *HYPCALL(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
-    std::string code = IMMEDIATE(copy(code_value));
+    char *code = IMMEDIATE(copy(code_value));
 
     return img_format("HYPCALL %s", code);
 }
@@ -7737,11 +7639,11 @@ static std::string HYPCALL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string HYPCALL_16_(uint64 instruction, img_address m_pc)
+static char *HYPCALL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
-    std::string code = IMMEDIATE(copy(code_value));
+    char *code = IMMEDIATE(copy(code_value));
 
     return img_format("HYPCALL %s", code);
 }
@@ -7757,17 +7659,17 @@ static std::string HYPCALL_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string INS(uint64 instruction, img_address m_pc)
+static char *INS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    std::string size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
+    char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("INS %s, %s, %s, %s", rt, rs, pos, size);
@@ -7784,13 +7686,13 @@ static std::string INS(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string INSV(uint64 instruction, img_address m_pc)
+static char *INSV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("INSV %s, %s", rt, rs);
 }
@@ -7806,11 +7708,11 @@ static std::string INSV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string IRET(uint64 instruction, img_address m_pc)
+static char *IRET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "IRET ";
+    return (char *)"IRET ";
 }
 
 
@@ -7824,11 +7726,11 @@ static std::string IRET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string JALRC_16_(uint64 instruction, img_address m_pc)
+static char *JALRC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
 
-    std::string rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("JALRC $%d, %s", 31, rt);
 }
@@ -7844,13 +7746,13 @@ static std::string JALRC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string JALRC_32_(uint64 instruction, img_address m_pc)
+static char *JALRC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("JALRC %s, %s", rt, rs);
 }
@@ -7866,13 +7768,13 @@ static std::string JALRC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string JALRC_HB(uint64 instruction, img_address m_pc)
+static char *JALRC_HB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("JALRC.HB %s, %s", rt, rs);
 }
@@ -7888,11 +7790,11 @@ static std::string JALRC_HB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string JRC(uint64 instruction, img_address m_pc)
+static char *JRC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
 
-    std::string rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("JRC %s", rt);
 }
@@ -7908,15 +7810,15 @@ static std::string JRC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LB_16_(uint64 instruction, img_address m_pc)
+static char *LB_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_1_0(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LB %s, %s(%s)", rt3, u, rs3);
 }
@@ -7932,13 +7834,13 @@ static std::string LB_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LB_GP_(uint64 instruction, img_address m_pc)
+static char *LB_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LB %s, %s($%d)", rt, u, 28);
 }
@@ -7954,15 +7856,15 @@ static std::string LB_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LB_S9_(uint64 instruction, img_address m_pc)
+static char *LB_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LB %s, %s(%s)", rt, s, rs);
 }
@@ -7978,15 +7880,15 @@ static std::string LB_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LB_U12_(uint64 instruction, img_address m_pc)
+static char *LB_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LB %s, %s(%s)", rt, u, rs);
 }
@@ -8002,15 +7904,15 @@ static std::string LB_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LBE(uint64 instruction, img_address m_pc)
+static char *LBE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LBE %s, %s(%s)", rt, s, rs);
 }
@@ -8026,15 +7928,15 @@ static std::string LBE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LBU_16_(uint64 instruction, img_address m_pc)
+static char *LBU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_1_0(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LBU %s, %s(%s)", rt3, u, rs3);
 }
@@ -8050,13 +7952,13 @@ static std::string LBU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LBU_GP_(uint64 instruction, img_address m_pc)
+static char *LBU_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LBU %s, %s($%d)", rt, u, 28);
 }
@@ -8072,15 +7974,15 @@ static std::string LBU_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LBU_S9_(uint64 instruction, img_address m_pc)
+static char *LBU_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LBU %s, %s(%s)", rt, s, rs);
 }
@@ -8096,15 +7998,15 @@ static std::string LBU_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LBU_U12_(uint64 instruction, img_address m_pc)
+static char *LBU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LBU %s, %s(%s)", rt, u, rs);
 }
@@ -8120,15 +8022,15 @@ static std::string LBU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LBUE(uint64 instruction, img_address m_pc)
+static char *LBUE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LBUE %s, %s(%s)", rt, s, rs);
 }
@@ -8144,15 +8046,15 @@ static std::string LBUE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LBUX(uint64 instruction, img_address m_pc)
+static char *LBUX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LBUX %s, %s(%s)", rd, rs, rt);
 }
@@ -8168,15 +8070,15 @@ static std::string LBUX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LBX(uint64 instruction, img_address m_pc)
+static char *LBX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LBX %s, %s(%s)", rd, rs, rt);
 }
@@ -8192,13 +8094,13 @@ static std::string LBX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LD_GP_(uint64 instruction, img_address m_pc)
+static char *LD_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_3__s3(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LD %s, %s($%d)", rt, u, 28);
 }
@@ -8214,15 +8116,15 @@ static std::string LD_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LD_S9_(uint64 instruction, img_address m_pc)
+static char *LD_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LD %s, %s(%s)", rt, s, rs);
 }
@@ -8238,15 +8140,15 @@ static std::string LD_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LD_U12_(uint64 instruction, img_address m_pc)
+static char *LD_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LD %s, %s(%s)", rt, u, rs);
 }
@@ -8262,13 +8164,13 @@ static std::string LD_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LDC1_GP_(uint64 instruction, img_address m_pc)
+static char *LDC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *ft = FPR(copy(ft_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LDC1 %s, %s($%d)", ft, u, 28);
 }
@@ -8284,15 +8186,15 @@ static std::string LDC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LDC1_S9_(uint64 instruction, img_address m_pc)
+static char *LDC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy(ft_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LDC1 %s, %s(%s)", ft, s, rs);
 }
@@ -8308,15 +8210,15 @@ static std::string LDC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LDC1_U12_(uint64 instruction, img_address m_pc)
+static char *LDC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy(ft_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LDC1 %s, %s(%s)", ft, u, rs);
 }
@@ -8332,15 +8234,15 @@ static std::string LDC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LDC1XS(uint64 instruction, img_address m_pc)
+static char *LDC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LDC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -8356,15 +8258,15 @@ static std::string LDC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LDC1X(uint64 instruction, img_address m_pc)
+static char *LDC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LDC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -8380,15 +8282,15 @@ static std::string LDC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LDC2(uint64 instruction, img_address m_pc)
+static char *LDC2(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string ct = CPR(copy(ct_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *ct = CPR(copy(ct_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LDC2 %s, %s(%s)", ct, s, rs);
 }
@@ -8404,17 +8306,17 @@ static std::string LDC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LDM(uint64 instruction, img_address m_pc)
+static char *LDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
+    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("LDM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -8430,13 +8332,13 @@ static std::string LDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LDPC_48_(uint64 instruction, img_address m_pc)
+static char *LDPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("LDPC %s, %s", rt, s);
 }
@@ -8452,15 +8354,15 @@ static std::string LDPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LDX(uint64 instruction, img_address m_pc)
+static char *LDX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LDX %s, %s(%s)", rd, rs, rt);
 }
@@ -8476,15 +8378,15 @@ static std::string LDX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LDXS(uint64 instruction, img_address m_pc)
+static char *LDXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LDXS %s, %s(%s)", rd, rs, rt);
 }
@@ -8500,15 +8402,15 @@ static std::string LDXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LH_16_(uint64 instruction, img_address m_pc)
+static char *LH_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_2_1__s1(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LH %s, %s(%s)", rt3, u, rs3);
 }
@@ -8524,13 +8426,13 @@ static std::string LH_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LH_GP_(uint64 instruction, img_address m_pc)
+static char *LH_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LH %s, %s($%d)", rt, u, 28);
 }
@@ -8546,15 +8448,15 @@ static std::string LH_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LH_S9_(uint64 instruction, img_address m_pc)
+static char *LH_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LH %s, %s(%s)", rt, s, rs);
 }
@@ -8570,15 +8472,15 @@ static std::string LH_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LH_U12_(uint64 instruction, img_address m_pc)
+static char *LH_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LH %s, %s(%s)", rt, u, rs);
 }
@@ -8594,15 +8496,15 @@ static std::string LH_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LHE(uint64 instruction, img_address m_pc)
+static char *LHE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LHE %s, %s(%s)", rt, s, rs);
 }
@@ -8618,15 +8520,15 @@ static std::string LHE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LHU_16_(uint64 instruction, img_address m_pc)
+static char *LHU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_2_1__s1(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LHU %s, %s(%s)", rt3, u, rs3);
 }
@@ -8642,13 +8544,13 @@ static std::string LHU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LHU_GP_(uint64 instruction, img_address m_pc)
+static char *LHU_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LHU %s, %s($%d)", rt, u, 28);
 }
@@ -8664,15 +8566,15 @@ static std::string LHU_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LHU_S9_(uint64 instruction, img_address m_pc)
+static char *LHU_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LHU %s, %s(%s)", rt, s, rs);
 }
@@ -8688,15 +8590,15 @@ static std::string LHU_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LHU_U12_(uint64 instruction, img_address m_pc)
+static char *LHU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LHU %s, %s(%s)", rt, u, rs);
 }
@@ -8712,15 +8614,15 @@ static std::string LHU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LHUE(uint64 instruction, img_address m_pc)
+static char *LHUE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LHUE %s, %s(%s)", rt, s, rs);
 }
@@ -8736,15 +8638,15 @@ static std::string LHUE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LHUX(uint64 instruction, img_address m_pc)
+static char *LHUX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LHUX %s, %s(%s)", rd, rs, rt);
 }
@@ -8760,15 +8662,15 @@ static std::string LHUX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LHUXS(uint64 instruction, img_address m_pc)
+static char *LHUXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LHUXS %s, %s(%s)", rd, rs, rt);
 }
@@ -8784,15 +8686,15 @@ static std::string LHUXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LHXS(uint64 instruction, img_address m_pc)
+static char *LHXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LHXS %s, %s(%s)", rd, rs, rt);
 }
@@ -8808,15 +8710,15 @@ static std::string LHXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LHX(uint64 instruction, img_address m_pc)
+static char *LHX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LHX %s, %s(%s)", rd, rs, rt);
 }
@@ -8832,13 +8734,13 @@ static std::string LHX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LI_16_(uint64 instruction, img_address m_pc)
+static char *LI_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
 
     return img_format("LI %s, %s", rt3, eu);
 }
@@ -8854,13 +8756,13 @@ static std::string LI_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LI_48_(uint64 instruction, img_address m_pc)
+static char *LI_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
 
     return img_format("LI %s, %s", rt, s);
 }
@@ -8876,15 +8778,15 @@ static std::string LI_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LL(uint64 instruction, img_address m_pc)
+static char *LL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LL %s, %s(%s)", rt, s, rs);
 }
@@ -8900,15 +8802,15 @@ static std::string LL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LLD(uint64 instruction, img_address m_pc)
+static char *LLD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LLD %s, %s(%s)", rt, s, rs);
 }
@@ -8924,15 +8826,15 @@ static std::string LLD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LLDP(uint64 instruction, img_address m_pc)
+static char *LLDP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ru = GPR(copy(ru_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ru = GPR(copy(ru_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LLDP %s, %s, (%s)", rt, ru, rs);
 }
@@ -8948,15 +8850,15 @@ static std::string LLDP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LLE(uint64 instruction, img_address m_pc)
+static char *LLE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LLE %s, %s(%s)", rt, s, rs);
 }
@@ -8972,15 +8874,15 @@ static std::string LLE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LLWP(uint64 instruction, img_address m_pc)
+static char *LLWP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ru = GPR(copy(ru_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ru = GPR(copy(ru_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LLWP %s, %s, (%s)", rt, ru, rs);
 }
@@ -8996,15 +8898,15 @@ static std::string LLWP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LLWPE(uint64 instruction, img_address m_pc)
+static char *LLWPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ru = GPR(copy(ru_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ru = GPR(copy(ru_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LLWPE %s, %s, (%s)", rt, ru, rs);
 }
@@ -9020,17 +8922,17 @@ static std::string LLWPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LSA(uint64 instruction, img_address m_pc)
+static char *LSA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 u2_value = extract_u2_10_9(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string u2 = IMMEDIATE(copy(u2_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u2 = IMMEDIATE(copy(u2_value));
 
     return img_format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
 }
@@ -9046,13 +8948,13 @@ static std::string LSA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LUI(uint64 instruction, img_address m_pc)
+static char *LUI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
 
     return img_format("LUI %s, %%hi(%s)", rt, s);
 }
@@ -9068,15 +8970,15 @@ static std::string LUI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LW_16_(uint64 instruction, img_address m_pc)
+static char *LW_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_3_2_1_0__s2(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LW %s, %s(%s)", rt3, u, rs3);
 }
@@ -9092,15 +8994,15 @@ static std::string LW_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LW_4X4_(uint64 instruction, img_address m_pc)
+static char *LW_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
     uint64 u_value = extract_u_3_8__s2(instruction);
 
-    std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
+    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
 
     return img_format("LW %s, %s(%s)", rt4, u, rs4);
 }
@@ -9116,13 +9018,13 @@ static std::string LW_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LW_GP_(uint64 instruction, img_address m_pc)
+static char *LW_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LW %s, %s($%d)", rt, u, 28);
 }
@@ -9138,13 +9040,13 @@ static std::string LW_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LW_GP16_(uint64 instruction, img_address m_pc)
+static char *LW_GP16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LW %s, %s($%d)", rt3, u, 28);
 }
@@ -9160,15 +9062,15 @@ static std::string LW_GP16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LW_S9_(uint64 instruction, img_address m_pc)
+static char *LW_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LW %s, %s(%s)", rt, s, rs);
 }
@@ -9184,13 +9086,13 @@ static std::string LW_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LW_SP_(uint64 instruction, img_address m_pc)
+static char *LW_SP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LW %s, %s($%d)", rt, u, 29);
 }
@@ -9206,15 +9108,15 @@ static std::string LW_SP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LW_U12_(uint64 instruction, img_address m_pc)
+static char *LW_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LW %s, %s(%s)", rt, u, rs);
 }
@@ -9230,13 +9132,13 @@ static std::string LW_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWC1_GP_(uint64 instruction, img_address m_pc)
+static char *LWC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *ft = FPR(copy(ft_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LWC1 %s, %s($%d)", ft, u, 28);
 }
@@ -9252,15 +9154,15 @@ static std::string LWC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWC1_S9_(uint64 instruction, img_address m_pc)
+static char *LWC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy(ft_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LWC1 %s, %s(%s)", ft, s, rs);
 }
@@ -9276,15 +9178,15 @@ static std::string LWC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWC1_U12_(uint64 instruction, img_address m_pc)
+static char *LWC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy(ft_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LWC1 %s, %s(%s)", ft, u, rs);
 }
@@ -9300,15 +9202,15 @@ static std::string LWC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWC1X(uint64 instruction, img_address m_pc)
+static char *LWC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LWC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -9324,15 +9226,15 @@ static std::string LWC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWC1XS(uint64 instruction, img_address m_pc)
+static char *LWC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LWC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -9348,15 +9250,15 @@ static std::string LWC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWC2(uint64 instruction, img_address m_pc)
+static char *LWC2(uint64 instruction, img_address m_pc)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string ct = CPR(copy(ct_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *ct = CPR(copy(ct_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LWC2 %s, %s(%s)", ct, s, rs);
 }
@@ -9372,15 +9274,15 @@ static std::string LWC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWE(uint64 instruction, img_address m_pc)
+static char *LWE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LWE %s, %s(%s)", rt, s, rs);
 }
@@ -9396,17 +9298,17 @@ static std::string LWE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWM(uint64 instruction, img_address m_pc)
+static char *LWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
+    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("LWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -9422,13 +9324,13 @@ static std::string LWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWPC_48_(uint64 instruction, img_address m_pc)
+static char *LWPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("LWPC %s, %s", rt, s);
 }
@@ -9444,13 +9346,13 @@ static std::string LWPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWU_GP_(uint64 instruction, img_address m_pc)
+static char *LWU_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LWU %s, %s($%d)", rt, u, 28);
 }
@@ -9466,15 +9368,15 @@ static std::string LWU_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWU_S9_(uint64 instruction, img_address m_pc)
+static char *LWU_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LWU %s, %s(%s)", rt, s, rs);
 }
@@ -9490,15 +9392,15 @@ static std::string LWU_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWU_U12_(uint64 instruction, img_address m_pc)
+static char *LWU_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("LWU %s, %s(%s)", rt, u, rs);
 }
@@ -9514,15 +9416,15 @@ static std::string LWU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWUX(uint64 instruction, img_address m_pc)
+static char *LWUX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LWUX %s, %s(%s)", rd, rs, rt);
 }
@@ -9538,15 +9440,15 @@ static std::string LWUX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWUXS(uint64 instruction, img_address m_pc)
+static char *LWUXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LWUXS %s, %s(%s)", rd, rs, rt);
 }
@@ -9562,15 +9464,15 @@ static std::string LWUXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWX(uint64 instruction, img_address m_pc)
+static char *LWX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LWX %s, %s(%s)", rd, rs, rt);
 }
@@ -9586,15 +9488,15 @@ static std::string LWX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWXS_16_(uint64 instruction, img_address m_pc)
+static char *LWXS_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 rd3_value = extract_rd3_3_2_1(instruction);
 
-    std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    std::string rt3 = IMMEDIATE(decode_gpr_gpr3(rt3_value));
+    const char *rd3 = GPR(decode_gpr_gpr3(rd3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    char *rt3 = IMMEDIATE(decode_gpr_gpr3(rt3_value));
 
     return img_format("LWXS %s, %s(%s)", rd3, rs3, rt3);
 }
@@ -9610,15 +9512,15 @@ static std::string LWXS_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string LWXS_32_(uint64 instruction, img_address m_pc)
+static char *LWXS_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("LWXS %s, %s(%s)", rd, rs, rt);
 }
@@ -9635,15 +9537,15 @@ static std::string LWXS_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MADD_DSP_(uint64 instruction, img_address m_pc)
+static char *MADD_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MADD %s, %s, %s", ac, rs, rt);
 }
@@ -9659,15 +9561,15 @@ static std::string MADD_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MADDF_D(uint64 instruction, img_address m_pc)
+static char *MADDF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MADDF.D %s, %s, %s", fd, fs, ft);
 }
@@ -9683,15 +9585,15 @@ static std::string MADDF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MADDF_S(uint64 instruction, img_address m_pc)
+static char *MADDF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MADDF.S %s, %s, %s", fd, fs, ft);
 }
@@ -9708,15 +9610,15 @@ static std::string MADDF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MADDU_DSP_(uint64 instruction, img_address m_pc)
+static char *MADDU_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MADDU %s, %s, %s", ac, rs, rt);
 }
@@ -9733,15 +9635,15 @@ static std::string MADDU_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MAQ_S_W_PHL(uint64 instruction, img_address m_pc)
+static char *MAQ_S_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
 }
@@ -9758,15 +9660,15 @@ static std::string MAQ_S_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MAQ_S_W_PHR(uint64 instruction, img_address m_pc)
+static char *MAQ_S_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
 }
@@ -9783,15 +9685,15 @@ static std::string MAQ_S_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MAQ_SA_W_PHL(uint64 instruction, img_address m_pc)
+static char *MAQ_SA_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
 }
@@ -9808,15 +9710,15 @@ static std::string MAQ_SA_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MAQ_SA_W_PHR(uint64 instruction, img_address m_pc)
+static char *MAQ_SA_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
 }
@@ -9832,15 +9734,15 @@ static std::string MAQ_SA_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MAX_D(uint64 instruction, img_address m_pc)
+static char *MAX_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MAX.D %s, %s, %s", fd, fs, ft);
 }
@@ -9856,15 +9758,15 @@ static std::string MAX_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MAX_S(uint64 instruction, img_address m_pc)
+static char *MAX_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MAX.S %s, %s, %s", fd, fs, ft);
 }
@@ -9880,15 +9782,15 @@ static std::string MAX_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MAXA_D(uint64 instruction, img_address m_pc)
+static char *MAXA_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MAXA.D %s, %s, %s", fd, fs, ft);
 }
@@ -9904,15 +9806,15 @@ static std::string MAXA_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MAXA_S(uint64 instruction, img_address m_pc)
+static char *MAXA_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MAXA.S %s, %s, %s", fd, fs, ft);
 }
@@ -9928,15 +9830,15 @@ static std::string MAXA_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MFC0(uint64 instruction, img_address m_pc)
+static char *MFC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -9952,13 +9854,13 @@ static std::string MFC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MFC1(uint64 instruction, img_address m_pc)
+static char *MFC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("MFC1 %s, %s", rt, fs);
 }
@@ -9974,13 +9876,13 @@ static std::string MFC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MFC2(uint64 instruction, img_address m_pc)
+static char *MFC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *cs = CPR(copy(cs_value));
 
     return img_format("MFC2 %s, %s", rt, cs);
 }
@@ -9996,15 +9898,15 @@ static std::string MFC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MFGC0(uint64 instruction, img_address m_pc)
+static char *MFGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10020,15 +9922,15 @@ static std::string MFGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MFHC0(uint64 instruction, img_address m_pc)
+static char *MFHC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFHC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10044,13 +9946,13 @@ static std::string MFHC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MFHC1(uint64 instruction, img_address m_pc)
+static char *MFHC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("MFHC1 %s, %s", rt, fs);
 }
@@ -10066,13 +9968,13 @@ static std::string MFHC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MFHC2(uint64 instruction, img_address m_pc)
+static char *MFHC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *cs = CPR(copy(cs_value));
 
     return img_format("MFHC2 %s, %s", rt, cs);
 }
@@ -10088,15 +9990,15 @@ static std::string MFHC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MFHGC0(uint64 instruction, img_address m_pc)
+static char *MFHGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFHGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10111,13 +10013,13 @@ static std::string MFHGC0(uint64 instruction, img_address m_pc)
  *     rt -----
  *               ac --
  */
-static std::string MFHI_DSP_(uint64 instruction, img_address m_pc)
+static char *MFHI_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
 
     return img_format("MFHI %s, %s", rt, ac);
 }
@@ -10133,17 +10035,17 @@ static std::string MFHI_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MFHTR(uint64 instruction, img_address m_pc)
+static char *MFHTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = IMMEDIATE(copy(c0s_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = IMMEDIATE(copy(c0s_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -10158,13 +10060,13 @@ static std::string MFHTR(uint64 instruction, img_address m_pc)
  *     rt -----
  *               ac --
  */
-static std::string MFLO_DSP_(uint64 instruction, img_address m_pc)
+static char *MFLO_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ac = AC(copy(ac_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
 
     return img_format("MFLO %s, %s", rt, ac);
 }
@@ -10180,17 +10082,17 @@ static std::string MFLO_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MFTR(uint64 instruction, img_address m_pc)
+static char *MFTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = IMMEDIATE(copy(c0s_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = IMMEDIATE(copy(c0s_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -10206,15 +10108,15 @@ static std::string MFTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MIN_D(uint64 instruction, img_address m_pc)
+static char *MIN_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MIN.D %s, %s, %s", fd, fs, ft);
 }
@@ -10230,15 +10132,15 @@ static std::string MIN_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MIN_S(uint64 instruction, img_address m_pc)
+static char *MIN_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MIN.S %s, %s, %s", fd, fs, ft);
 }
@@ -10254,15 +10156,15 @@ static std::string MIN_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MINA_D(uint64 instruction, img_address m_pc)
+static char *MINA_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MINA.D %s, %s, %s", fd, fs, ft);
 }
@@ -10278,15 +10180,15 @@ static std::string MINA_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MINA_S(uint64 instruction, img_address m_pc)
+static char *MINA_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MINA.S %s, %s, %s", fd, fs, ft);
 }
@@ -10302,15 +10204,15 @@ static std::string MINA_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MOD(uint64 instruction, img_address m_pc)
+static char *MOD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MOD %s, %s, %s", rd, rs, rt);
 }
@@ -10326,15 +10228,15 @@ static std::string MOD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MODSUB(uint64 instruction, img_address m_pc)
+static char *MODSUB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MODSUB %s, %s, %s", rd, rs, rt);
 }
@@ -10350,15 +10252,15 @@ static std::string MODSUB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MODU(uint64 instruction, img_address m_pc)
+static char *MODU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MODU %s, %s, %s", rd, rs, rt);
 }
@@ -10374,13 +10276,13 @@ static std::string MODU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MOV_D(uint64 instruction, img_address m_pc)
+static char *MOV_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("MOV.D %s, %s", ft, fs);
 }
@@ -10396,13 +10298,13 @@ static std::string MOV_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MOV_S(uint64 instruction, img_address m_pc)
+static char *MOV_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("MOV.S %s, %s", ft, fs);
 }
@@ -10418,15 +10320,15 @@ static std::string MOV_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MOVE_BALC(uint64 instruction, img_address m_pc)
+static char *MOVE_BALC(uint64 instruction, img_address m_pc)
 {
     uint64 rtz4_value = extract_rtz4_27_26_25_23_22_21(instruction);
     uint64 rd1_value = extract_rdl_25_24(instruction);
     int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
 
-    std::string rd1 = GPR(decode_gpr_gpr1(rd1_value));
-    std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rd1 = GPR(decode_gpr_gpr1(rd1_value));
+    const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
 }
@@ -10442,17 +10344,17 @@ static std::string MOVE_BALC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MOVEP(uint64 instruction, img_address m_pc)
+static char *MOVEP(uint64 instruction, img_address m_pc)
 {
     uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
     uint64 rd2_value = extract_rd2_3_8(instruction);
     uint64 rsz4_value = extract_rsz4_4_2_1_0(instruction);
 
-    std::string rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value));
-    std::string re2 = GPR(decode_gpr_gpr2_reg2(rd2_value));
+    const char *rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value));
+    const char *re2 = GPR(decode_gpr_gpr2_reg2(rd2_value));
     /* !!!!!!!!!! - no conversion function */
-    std::string rsz4 = GPR(decode_gpr_gpr4_zero(rsz4_value));
-    std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
+    const char *rsz4 = GPR(decode_gpr_gpr4_zero(rsz4_value));
+    const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
 
     return img_format("MOVEP %s, %s, %s, %s", rd2, re2, rsz4, rtz4);
     /* hand edited */
@@ -10469,16 +10371,16 @@ static std::string MOVEP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MOVEP_REV_(uint64 instruction, img_address m_pc)
+static char *MOVEP_REV_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rd2_value = extract_rd2_3_8(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
 
-    std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
-    std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
-    std::string rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value));
-    std::string rs2 = GPR(decode_gpr_gpr2_reg2(rd2_value));
+    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
+    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value));
+    const char *rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value));
+    const char *rs2 = GPR(decode_gpr_gpr2_reg2(rd2_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("MOVEP %s, %s, %s, %s", rs4, rt4, rd2, rs2);
@@ -10496,13 +10398,13 @@ static std::string MOVEP_REV_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MOVE(uint64 instruction, img_address m_pc)
+static char *MOVE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("MOVE %s, %s", rt, rs);
 }
@@ -10518,15 +10420,15 @@ static std::string MOVE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MOVN(uint64 instruction, img_address m_pc)
+static char *MOVN(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MOVN %s, %s, %s", rd, rs, rt);
 }
@@ -10542,15 +10444,15 @@ static std::string MOVN(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MOVZ(uint64 instruction, img_address m_pc)
+static char *MOVZ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MOVZ %s, %s, %s", rd, rs, rt);
 }
@@ -10566,15 +10468,15 @@ static std::string MOVZ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string MSUB_DSP_(uint64 instruction, img_address m_pc)
+static char *MSUB_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MSUB %s, %s, %s", ac, rs, rt);
 }
@@ -10590,15 +10492,15 @@ static std::string MSUB_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MSUBF_D(uint64 instruction, img_address m_pc)
+static char *MSUBF_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MSUBF.D %s, %s, %s", fd, fs, ft);
 }
@@ -10614,15 +10516,15 @@ static std::string MSUBF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MSUBF_S(uint64 instruction, img_address m_pc)
+static char *MSUBF_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MSUBF.S %s, %s, %s", fd, fs, ft);
 }
@@ -10638,15 +10540,15 @@ static std::string MSUBF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string MSUBU_DSP_(uint64 instruction, img_address m_pc)
+static char *MSUBU_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MSUBU %s, %s, %s", ac, rs, rt);
 }
@@ -10662,15 +10564,15 @@ static std::string MSUBU_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MTC0(uint64 instruction, img_address m_pc)
+static char *MTC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10686,13 +10588,13 @@ static std::string MTC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MTC1(uint64 instruction, img_address m_pc)
+static char *MTC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("MTC1 %s, %s", rt, fs);
 }
@@ -10708,13 +10610,13 @@ static std::string MTC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MTC2(uint64 instruction, img_address m_pc)
+static char *MTC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *cs = CPR(copy(cs_value));
 
     return img_format("MTC2 %s, %s", rt, cs);
 }
@@ -10730,15 +10632,15 @@ static std::string MTC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MTGC0(uint64 instruction, img_address m_pc)
+static char *MTGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10754,15 +10656,15 @@ static std::string MTGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MTHC0(uint64 instruction, img_address m_pc)
+static char *MTHC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTHC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10778,13 +10680,13 @@ static std::string MTHC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MTHC1(uint64 instruction, img_address m_pc)
+static char *MTHC1(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("MTHC1 %s, %s", rt, fs);
 }
@@ -10800,13 +10702,13 @@ static std::string MTHC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MTHC2(uint64 instruction, img_address m_pc)
+static char *MTHC2(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *cs = CPR(copy(cs_value));
 
     return img_format("MTHC2 %s, %s", rt, cs);
 }
@@ -10822,15 +10724,15 @@ static std::string MTHC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MTHGC0(uint64 instruction, img_address m_pc)
+static char *MTHGC0(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = CPR(copy(c0s_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = CPR(copy(c0s_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTHGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10845,13 +10747,13 @@ static std::string MTHGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string MTHI_DSP_(uint64 instruction, img_address m_pc)
+static char *MTHI_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *ac = AC(copy(ac_value));
 
     return img_format("MTHI %s, %s", rs, ac);
 }
@@ -10866,13 +10768,13 @@ static std::string MTHI_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string MTHLIP(uint64 instruction, img_address m_pc)
+static char *MTHLIP(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *ac = AC(copy(ac_value));
 
     return img_format("MTHLIP %s, %s", rs, ac);
 }
@@ -10888,17 +10790,17 @@ static std::string MTHLIP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MTHTR(uint64 instruction, img_address m_pc)
+static char *MTHTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = IMMEDIATE(copy(c0s_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = IMMEDIATE(copy(c0s_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -10913,13 +10815,13 @@ static std::string MTHTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string MTLO_DSP_(uint64 instruction, img_address m_pc)
+static char *MTLO_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *ac = AC(copy(ac_value));
 
     return img_format("MTLO %s, %s", rs, ac);
 }
@@ -10935,17 +10837,17 @@ static std::string MTLO_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MTTR(uint64 instruction, img_address m_pc)
+static char *MTTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string c0s = IMMEDIATE(copy(c0s_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *c0s = IMMEDIATE(copy(c0s_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -10961,15 +10863,15 @@ static std::string MTTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MUH(uint64 instruction, img_address m_pc)
+static char *MUH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MUH %s, %s, %s", rd, rs, rt);
 }
@@ -10985,15 +10887,15 @@ static std::string MUH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MUHU(uint64 instruction, img_address m_pc)
+static char *MUHU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MUHU %s, %s, %s", rd, rs, rt);
 }
@@ -11009,15 +10911,15 @@ static std::string MUHU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MUL_32_(uint64 instruction, img_address m_pc)
+static char *MUL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MUL %s, %s, %s", rd, rs, rt);
 }
@@ -11033,13 +10935,13 @@ static std::string MUL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MUL_4X4_(uint64 instruction, img_address m_pc)
+static char *MUL_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
 
-    std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
-    std::string rt4 = GPR(decode_gpr_gpr4(rt4_value));
+    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
+    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value));
 
     return img_format("MUL %s, %s", rs4, rt4);
 }
@@ -11055,15 +10957,15 @@ static std::string MUL_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MUL_D(uint64 instruction, img_address m_pc)
+static char *MUL_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MUL.D %s, %s, %s", fd, fs, ft);
 }
@@ -11080,15 +10982,15 @@ static std::string MUL_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MUL_PH(uint64 instruction, img_address m_pc)
+static char *MUL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MUL.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11105,15 +11007,15 @@ static std::string MUL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MUL_S_PH(uint64 instruction, img_address m_pc)
+static char *MUL_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MUL_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11129,15 +11031,15 @@ static std::string MUL_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MUL_S(uint64 instruction, img_address m_pc)
+static char *MUL_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("MUL.S %s, %s, %s", fd, fs, ft);
 }
@@ -11154,15 +11056,15 @@ static std::string MUL_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MULEQ_S_W_PHL(uint64 instruction, img_address m_pc)
+static char *MULEQ_S_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
 }
@@ -11179,15 +11081,15 @@ static std::string MULEQ_S_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MULEQ_S_W_PHR(uint64 instruction, img_address m_pc)
+static char *MULEQ_S_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
 }
@@ -11204,15 +11106,15 @@ static std::string MULEQ_S_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MULEU_S_PH_QBL(uint64 instruction, img_address m_pc)
+static char *MULEU_S_PH_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
 }
@@ -11229,15 +11131,15 @@ static std::string MULEU_S_PH_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MULEU_S_PH_QBR(uint64 instruction, img_address m_pc)
+static char *MULEU_S_PH_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
 }
@@ -11254,15 +11156,15 @@ static std::string MULEU_S_PH_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MULQ_RS_PH(uint64 instruction, img_address m_pc)
+static char *MULQ_RS_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11279,15 +11181,15 @@ static std::string MULQ_RS_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MULQ_RS_W(uint64 instruction, img_address m_pc)
+static char *MULQ_RS_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
 }
@@ -11304,15 +11206,15 @@ static std::string MULQ_RS_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MULQ_S_PH(uint64 instruction, img_address m_pc)
+static char *MULQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11329,15 +11231,15 @@ static std::string MULQ_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MULQ_S_W(uint64 instruction, img_address m_pc)
+static char *MULQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULQ_S.W %s, %s, %s", rd, rs, rt);
 }
@@ -11354,15 +11256,15 @@ static std::string MULQ_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string MULSA_W_PH(uint64 instruction, img_address m_pc)
+static char *MULSA_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -11379,15 +11281,15 @@ static std::string MULSA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string MULSAQ_S_W_PH(uint64 instruction, img_address m_pc)
+static char *MULSAQ_S_W_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -11403,15 +11305,15 @@ static std::string MULSAQ_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string MULT_DSP_(uint64 instruction, img_address m_pc)
+static char *MULT_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULT %s, %s, %s", ac, rs, rt);
 }
@@ -11427,15 +11329,15 @@ static std::string MULT_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string MULTU_DSP_(uint64 instruction, img_address m_pc)
+static char *MULTU_DSP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string ac = AC(copy(ac_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULTU %s, %s, %s", ac, rs, rt);
 }
@@ -11451,15 +11353,15 @@ static std::string MULTU_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string MULU(uint64 instruction, img_address m_pc)
+static char *MULU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("MULU %s, %s, %s", rd, rs, rt);
 }
@@ -11475,13 +11377,13 @@ static std::string MULU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string NEG_D(uint64 instruction, img_address m_pc)
+static char *NEG_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("NEG.D %s, %s", ft, fs);
 }
@@ -11497,13 +11399,13 @@ static std::string NEG_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string NEG_S(uint64 instruction, img_address m_pc)
+static char *NEG_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("NEG.S %s, %s", ft, fs);
 }
@@ -11519,11 +11421,11 @@ static std::string NEG_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string NOP_16_(uint64 instruction, img_address m_pc)
+static char *NOP_16_(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "NOP ";
+    return (char *)"NOP ";
 }
 
 
@@ -11537,11 +11439,11 @@ static std::string NOP_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string NOP_32_(uint64 instruction, img_address m_pc)
+static char *NOP_32_(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "NOP ";
+    return (char *)"NOP ";
 }
 
 
@@ -11555,15 +11457,15 @@ static std::string NOP_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string NOR(uint64 instruction, img_address m_pc)
+static char *NOR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("NOR %s, %s, %s", rd, rs, rt);
 }
@@ -11579,13 +11481,13 @@ static std::string NOR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string NOT_16_(uint64 instruction, img_address m_pc)
+static char *NOT_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("NOT %s, %s", rt3, rs3);
 }
@@ -11601,13 +11503,13 @@ static std::string NOT_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string OR_16_(uint64 instruction, img_address m_pc)
+static char *OR_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
 
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
 
     return img_format("OR %s, %s", rs3, rt3);
 }
@@ -11623,15 +11525,15 @@ static std::string OR_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string OR_32_(uint64 instruction, img_address m_pc)
+static char *OR_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("OR %s, %s, %s", rd, rs, rt);
 }
@@ -11647,15 +11549,15 @@ static std::string OR_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ORI(uint64 instruction, img_address m_pc)
+static char *ORI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ORI %s, %s, %s", rt, rs, u);
 }
@@ -11672,15 +11574,15 @@ static std::string ORI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PACKRL_PH(uint64 instruction, img_address m_pc)
+static char *PACKRL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("PACKRL.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11696,11 +11598,11 @@ static std::string PACKRL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PAUSE(uint64 instruction, img_address m_pc)
+static char *PAUSE(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "PAUSE ";
+    return (char *)"PAUSE ";
 }
 
 
@@ -11715,15 +11617,15 @@ static std::string PAUSE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PICK_PH(uint64 instruction, img_address m_pc)
+static char *PICK_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("PICK.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11740,15 +11642,15 @@ static std::string PICK_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PICK_QB(uint64 instruction, img_address m_pc)
+static char *PICK_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("PICK.QB %s, %s, %s", rd, rs, rt);
 }
@@ -11765,13 +11667,13 @@ static std::string PICK_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECEQ_W_PHL(uint64 instruction, img_address m_pc)
+static char *PRECEQ_W_PHL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PRECEQ.W.PHL %s, %s", rt, rs);
 }
@@ -11788,13 +11690,13 @@ static std::string PRECEQ_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECEQ_W_PHR(uint64 instruction, img_address m_pc)
+static char *PRECEQ_W_PHR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PRECEQ.W.PHR %s, %s", rt, rs);
 }
@@ -11811,13 +11713,13 @@ static std::string PRECEQ_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc)
+static char *PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PRECEQU.PH.QBLA %s, %s", rt, rs);
 }
@@ -11834,13 +11736,13 @@ static std::string PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECEQU_PH_QBL(uint64 instruction, img_address m_pc)
+static char *PRECEQU_PH_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PRECEQU.PH.QBL %s, %s", rt, rs);
 }
@@ -11857,13 +11759,13 @@ static std::string PRECEQU_PH_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc)
+static char *PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PRECEQU.PH.QBRA %s, %s", rt, rs);
 }
@@ -11880,13 +11782,13 @@ static std::string PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECEQU_PH_QBR(uint64 instruction, img_address m_pc)
+static char *PRECEQU_PH_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PRECEQU.PH.QBR %s, %s", rt, rs);
 }
@@ -11904,13 +11806,13 @@ static std::string PRECEQU_PH_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECEU_PH_QBLA(uint64 instruction, img_address m_pc)
+static char *PRECEU_PH_QBLA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PRECEU.PH.QBLA %s, %s", rt, rs);
 }
@@ -11927,13 +11829,13 @@ static std::string PRECEU_PH_QBLA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECEU_PH_QBL(uint64 instruction, img_address m_pc)
+static char *PRECEU_PH_QBL(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PRECEU.PH.QBL %s, %s", rt, rs);
 }
@@ -11951,13 +11853,13 @@ static std::string PRECEU_PH_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECEU_PH_QBRA(uint64 instruction, img_address m_pc)
+static char *PRECEU_PH_QBRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PRECEU.PH.QBRA %s, %s", rt, rs);
 }
@@ -11974,13 +11876,13 @@ static std::string PRECEU_PH_QBRA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECEU_PH_QBR(uint64 instruction, img_address m_pc)
+static char *PRECEU_PH_QBR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PRECEU.PH.QBR %s, %s", rt, rs);
 }
@@ -11997,15 +11899,15 @@ static std::string PRECEU_PH_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECR_QB_PH(uint64 instruction, img_address m_pc)
+static char *PRECR_QB_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
 }
@@ -12022,15 +11924,15 @@ static std::string PRECR_QB_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECR_SRA_PH_W(uint64 instruction, img_address m_pc)
+static char *PRECR_SRA_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
 }
@@ -12047,15 +11949,15 @@ static std::string PRECR_SRA_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc)
+static char *PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
 }
@@ -12072,15 +11974,15 @@ static std::string PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECRQ_PH_W(uint64 instruction, img_address m_pc)
+static char *PRECRQ_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
 }
@@ -12097,15 +11999,15 @@ static std::string PRECRQ_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECRQ_QB_PH(uint64 instruction, img_address m_pc)
+static char *PRECRQ_QB_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
 }
@@ -12122,15 +12024,15 @@ static std::string PRECRQ_QB_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc)
+static char *PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
 }
@@ -12147,15 +12049,15 @@ static std::string PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc)
+static char *PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
 }
@@ -12171,15 +12073,15 @@ static std::string PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PREF_S9_(uint64 instruction, img_address m_pc)
+static char *PREF_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string hint = IMMEDIATE(copy(hint_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *hint = IMMEDIATE(copy(hint_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PREF %s, %s(%s)", hint, s, rs);
 }
@@ -12195,15 +12097,15 @@ static std::string PREF_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PREF_U12_(uint64 instruction, img_address m_pc)
+static char *PREF_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string hint = IMMEDIATE(copy(hint_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    char *hint = IMMEDIATE(copy(hint_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PREF %s, %s(%s)", hint, u, rs);
 }
@@ -12219,15 +12121,15 @@ static std::string PREF_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PREFE(uint64 instruction, img_address m_pc)
+static char *PREFE(uint64 instruction, img_address m_pc)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string hint = IMMEDIATE(copy(hint_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *hint = IMMEDIATE(copy(hint_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("PREFE %s, %s(%s)", hint, s, rs);
 }
@@ -12243,15 +12145,15 @@ static std::string PREFE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string PREPEND(uint64 instruction, img_address m_pc)
+static char *PREPEND(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("PREPEND %s, %s, %s", rt, rs, sa);
 }
@@ -12266,13 +12168,13 @@ static std::string PREPEND(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string RADDU_W_QB(uint64 instruction, img_address m_pc)
+static char *RADDU_W_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("RADDU.W.QB %s, %s", rt, rs);
 }
@@ -12287,13 +12189,13 @@ static std::string RADDU_W_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *        mask -------
  */
-static std::string RDDSP(uint64 instruction, img_address m_pc)
+static char *RDDSP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string mask = IMMEDIATE(copy(mask_value));
+    const char *rt = GPR(copy(rt_value));
+    char *mask = IMMEDIATE(copy(mask_value));
 
     return img_format("RDDSP %s, %s", rt, mask);
 }
@@ -12309,15 +12211,15 @@ static std::string RDDSP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RDHWR(uint64 instruction, img_address m_pc)
+static char *RDHWR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string hs = CPR(copy(hs_value));
-    std::string sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy(rt_value));
+    char *hs = CPR(copy(hs_value));
+    char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("RDHWR %s, %s, %s", rt, hs, sel);
 }
@@ -12333,13 +12235,13 @@ static std::string RDHWR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RDPGPR(uint64 instruction, img_address m_pc)
+static char *RDPGPR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("RDPGPR %s, %s", rt, rs);
 }
@@ -12355,13 +12257,13 @@ static std::string RDPGPR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RECIP_D(uint64 instruction, img_address m_pc)
+static char *RECIP_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("RECIP.D %s, %s", ft, fs);
 }
@@ -12377,13 +12279,13 @@ static std::string RECIP_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RECIP_S(uint64 instruction, img_address m_pc)
+static char *RECIP_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("RECIP.S %s, %s", ft, fs);
 }
@@ -12399,13 +12301,13 @@ static std::string RECIP_S(uint64 instruction, img_address m_pc)
  *     rt -----
  *           s ----------
  */
-static std::string REPL_PH(uint64 instruction, img_address m_pc)
+static char *REPL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se9_20_19_18_17_16_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
 
     return img_format("REPL.PH %s, %s", rt, s);
 }
@@ -12421,13 +12323,13 @@ static std::string REPL_PH(uint64 instruction, img_address m_pc)
  *     rt -----
  *           u --------
  */
-static std::string REPL_QB(uint64 instruction, img_address m_pc)
+static char *REPL_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("REPL.QB %s, %s", rt, u);
 }
@@ -12443,13 +12345,13 @@ static std::string REPL_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string REPLV_PH(uint64 instruction, img_address m_pc)
+static char *REPLV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("REPLV.PH %s, %s", rt, rs);
 }
@@ -12464,13 +12366,13 @@ static std::string REPLV_PH(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string REPLV_QB(uint64 instruction, img_address m_pc)
+static char *REPLV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("REPLV.QB %s, %s", rt, rs);
 }
@@ -12486,14 +12388,14 @@ static std::string REPLV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RESTORE_32_(uint64 instruction, img_address m_pc)
+static char *RESTORE_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
     uint64 gp_value = extract_gp_2(instruction);
 
-    std::string u = IMMEDIATE(copy(u_value));
+    char *u = IMMEDIATE(copy(u_value));
     return img_format("RESTORE %s%s", u,
                save_restore_list(rt_value, count_value, gp_value));
 }
@@ -12509,13 +12411,13 @@ static std::string RESTORE_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
+static char *RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt1_value = extract_rtl_11(instruction);
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
     uint64 count_value = extract_count_3_2_1_0(instruction);
 
-    std::string u = IMMEDIATE(copy(u_value));
+    char *u = IMMEDIATE(copy(u_value));
     return img_format("RESTORE.JRC %s%s", u,
         save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
 }
@@ -12531,14 +12433,14 @@ static std::string RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
+static char *RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
     uint64 gp_value = extract_gp_2(instruction);
 
-    std::string u = IMMEDIATE(copy(u_value));
+    char *u = IMMEDIATE(copy(u_value));
     return img_format("RESTORE.JRC %s%s", u,
                save_restore_list(rt_value, count_value, gp_value));
 }
@@ -12554,13 +12456,13 @@ static std::string RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RESTOREF(uint64 instruction, img_address m_pc)
+static char *RESTOREF(uint64 instruction, img_address m_pc)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
 
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string count = IMMEDIATE(copy(count_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *count = IMMEDIATE(copy(count_value));
 
     return img_format("RESTOREF %s, %s", u, count);
 }
@@ -12576,13 +12478,13 @@ static std::string RESTOREF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RINT_D(uint64 instruction, img_address m_pc)
+static char *RINT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("RINT.D %s, %s", ft, fs);
 }
@@ -12598,13 +12500,13 @@ static std::string RINT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RINT_S(uint64 instruction, img_address m_pc)
+static char *RINT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("RINT.S %s, %s", ft, fs);
 }
@@ -12620,15 +12522,15 @@ static std::string RINT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ROTR(uint64 instruction, img_address m_pc)
+static char *ROTR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("ROTR %s, %s, %s", rt, rs, shift);
 }
@@ -12644,15 +12546,15 @@ static std::string ROTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ROTRV(uint64 instruction, img_address m_pc)
+static char *ROTRV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("ROTRV %s, %s, %s", rd, rs, rt);
 }
@@ -12668,7 +12570,7 @@ static std::string ROTRV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ROTX(uint64 instruction, img_address m_pc)
+static char *ROTX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12676,11 +12578,11 @@ static std::string ROTX(uint64 instruction, img_address m_pc)
     uint64 stripe_value = extract_stripe_6(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
-    std::string shiftx = IMMEDIATE(copy(shiftx_value));
-    std::string stripe = IMMEDIATE(copy(stripe_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
+    char *shiftx = IMMEDIATE(copy(shiftx_value));
+    char *stripe = IMMEDIATE(copy(stripe_value));
 
     return img_format("ROTX %s, %s, %s, %s, %s",
                        rt, rs, shift, shiftx, stripe);
@@ -12697,13 +12599,13 @@ static std::string ROTX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ROUND_L_D(uint64 instruction, img_address m_pc)
+static char *ROUND_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("ROUND.L.D %s, %s", ft, fs);
 }
@@ -12719,13 +12621,13 @@ static std::string ROUND_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ROUND_L_S(uint64 instruction, img_address m_pc)
+static char *ROUND_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("ROUND.L.S %s, %s", ft, fs);
 }
@@ -12741,13 +12643,13 @@ static std::string ROUND_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ROUND_W_D(uint64 instruction, img_address m_pc)
+static char *ROUND_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("ROUND.W.D %s, %s", ft, fs);
 }
@@ -12763,13 +12665,13 @@ static std::string ROUND_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string ROUND_W_S(uint64 instruction, img_address m_pc)
+static char *ROUND_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("ROUND.W.S %s, %s", ft, fs);
 }
@@ -12785,13 +12687,13 @@ static std::string ROUND_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RSQRT_D(uint64 instruction, img_address m_pc)
+static char *RSQRT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("RSQRT.D %s, %s", ft, fs);
 }
@@ -12807,13 +12709,13 @@ static std::string RSQRT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string RSQRT_S(uint64 instruction, img_address m_pc)
+static char *RSQRT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("RSQRT.S %s, %s", ft, fs);
 }
@@ -12829,13 +12731,13 @@ static std::string RSQRT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SAVE_16_(uint64 instruction, img_address m_pc)
+static char *SAVE_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt1_value = extract_rtl_11(instruction);
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
     uint64 count_value = extract_count_3_2_1_0(instruction);
 
-    std::string u = IMMEDIATE(copy(u_value));
+    char *u = IMMEDIATE(copy(u_value));
     return img_format("SAVE %s%s", u,
         save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
 }
@@ -12851,14 +12753,14 @@ static std::string SAVE_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SAVE_32_(uint64 instruction, img_address m_pc)
+static char *SAVE_32_(uint64 instruction, img_address m_pc)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
     uint64 gp_value = extract_gp_2(instruction);
 
-    std::string u = IMMEDIATE(copy(u_value));
+    char *u = IMMEDIATE(copy(u_value));
     return img_format("SAVE %s%s", u,
                save_restore_list(rt_value, count_value, gp_value));
 }
@@ -12874,13 +12776,13 @@ static std::string SAVE_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SAVEF(uint64 instruction, img_address m_pc)
+static char *SAVEF(uint64 instruction, img_address m_pc)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
 
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string count = IMMEDIATE(copy(count_value));
+    char *u = IMMEDIATE(copy(u_value));
+    char *count = IMMEDIATE(copy(count_value));
 
     return img_format("SAVEF %s, %s", u, count);
 }
@@ -12896,15 +12798,15 @@ static std::string SAVEF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SB_16_(uint64 instruction, img_address m_pc)
+static char *SB_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_1_0(instruction);
 
-    std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("SB %s, %s(%s)", rtz3, u, rs3);
 }
@@ -12920,13 +12822,13 @@ static std::string SB_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SB_GP_(uint64 instruction, img_address m_pc)
+static char *SB_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SB %s, %s($%d)", rt, u, 28);
 }
@@ -12942,15 +12844,15 @@ static std::string SB_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SB_S9_(uint64 instruction, img_address m_pc)
+static char *SB_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SB %s, %s(%s)", rt, s, rs);
 }
@@ -12966,15 +12868,15 @@ static std::string SB_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SB_U12_(uint64 instruction, img_address m_pc)
+static char *SB_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SB %s, %s(%s)", rt, u, rs);
 }
@@ -12990,15 +12892,15 @@ static std::string SB_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SBE(uint64 instruction, img_address m_pc)
+static char *SBE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SBE %s, %s(%s)", rt, s, rs);
 }
@@ -13014,15 +12916,15 @@ static std::string SBE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SBX(uint64 instruction, img_address m_pc)
+static char *SBX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SBX %s, %s(%s)", rd, rs, rt);
 }
@@ -13038,15 +12940,15 @@ static std::string SBX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SC(uint64 instruction, img_address m_pc)
+static char *SC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SC %s, %s(%s)", rt, s, rs);
 }
@@ -13062,15 +12964,15 @@ static std::string SC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SCD(uint64 instruction, img_address m_pc)
+static char *SCD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SCD %s, %s(%s)", rt, s, rs);
 }
@@ -13086,15 +12988,15 @@ static std::string SCD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SCDP(uint64 instruction, img_address m_pc)
+static char *SCDP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ru = GPR(copy(ru_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ru = GPR(copy(ru_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SCDP %s, %s, (%s)", rt, ru, rs);
 }
@@ -13110,15 +13012,15 @@ static std::string SCDP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SCE(uint64 instruction, img_address m_pc)
+static char *SCE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SCE %s, %s(%s)", rt, s, rs);
 }
@@ -13134,15 +13036,15 @@ static std::string SCE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SCWP(uint64 instruction, img_address m_pc)
+static char *SCWP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ru = GPR(copy(ru_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ru = GPR(copy(ru_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SCWP %s, %s, (%s)", rt, ru, rs);
 }
@@ -13158,15 +13060,15 @@ static std::string SCWP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SCWPE(uint64 instruction, img_address m_pc)
+static char *SCWPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string ru = GPR(copy(ru_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *ru = GPR(copy(ru_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SCWPE %s, %s, (%s)", rt, ru, rs);
 }
@@ -13182,13 +13084,13 @@ static std::string SCWPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SD_GP_(uint64 instruction, img_address m_pc)
+static char *SD_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_3__s3(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SD %s, %s($%d)", rt, u, 28);
 }
@@ -13204,15 +13106,15 @@ static std::string SD_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SD_S9_(uint64 instruction, img_address m_pc)
+static char *SD_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SD %s, %s(%s)", rt, s, rs);
 }
@@ -13228,15 +13130,15 @@ static std::string SD_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SD_U12_(uint64 instruction, img_address m_pc)
+static char *SD_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SD %s, %s(%s)", rt, u, rs);
 }
@@ -13252,11 +13154,11 @@ static std::string SD_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDBBP_16_(uint64 instruction, img_address m_pc)
+static char *SDBBP_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
-    std::string code = IMMEDIATE(copy(code_value));
+    char *code = IMMEDIATE(copy(code_value));
 
     return img_format("SDBBP %s", code);
 }
@@ -13272,11 +13174,11 @@ static std::string SDBBP_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDBBP_32_(uint64 instruction, img_address m_pc)
+static char *SDBBP_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
-    std::string code = IMMEDIATE(copy(code_value));
+    char *code = IMMEDIATE(copy(code_value));
 
     return img_format("SDBBP %s", code);
 }
@@ -13292,13 +13194,13 @@ static std::string SDBBP_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDC1_GP_(uint64 instruction, img_address m_pc)
+static char *SDC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *ft = FPR(copy(ft_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SDC1 %s, %s($%d)", ft, u, 28);
 }
@@ -13314,15 +13216,15 @@ static std::string SDC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDC1_S9_(uint64 instruction, img_address m_pc)
+static char *SDC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy(ft_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SDC1 %s, %s(%s)", ft, s, rs);
 }
@@ -13338,15 +13240,15 @@ static std::string SDC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDC1_U12_(uint64 instruction, img_address m_pc)
+static char *SDC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy(ft_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SDC1 %s, %s(%s)", ft, u, rs);
 }
@@ -13362,15 +13264,15 @@ static std::string SDC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDC1X(uint64 instruction, img_address m_pc)
+static char *SDC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SDC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -13386,15 +13288,15 @@ static std::string SDC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDC1XS(uint64 instruction, img_address m_pc)
+static char *SDC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SDC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -13410,15 +13312,15 @@ static std::string SDC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDC2(uint64 instruction, img_address m_pc)
+static char *SDC2(uint64 instruction, img_address m_pc)
 {
     uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string cs = CPR(copy(cs_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *cs = CPR(copy(cs_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SDC2 %s, %s(%s)", cs, s, rs);
 }
@@ -13434,17 +13336,17 @@ static std::string SDC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDM(uint64 instruction, img_address m_pc)
+static char *SDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
+    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("SDM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -13460,13 +13362,13 @@ static std::string SDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDPC_48_(uint64 instruction, img_address m_pc)
+static char *SDPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("SDPC %s, %s", rt, s);
 }
@@ -13482,15 +13384,15 @@ static std::string SDPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDXS(uint64 instruction, img_address m_pc)
+static char *SDXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SDXS %s, %s(%s)", rd, rs, rt);
 }
@@ -13506,15 +13408,15 @@ static std::string SDXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SDX(uint64 instruction, img_address m_pc)
+static char *SDX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SDX %s, %s(%s)", rd, rs, rt);
 }
@@ -13530,13 +13432,13 @@ static std::string SDX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SEB(uint64 instruction, img_address m_pc)
+static char *SEB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SEB %s, %s", rt, rs);
 }
@@ -13552,13 +13454,13 @@ static std::string SEB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SEH(uint64 instruction, img_address m_pc)
+static char *SEH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SEH %s, %s", rt, rs);
 }
@@ -13574,15 +13476,15 @@ static std::string SEH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SEL_D(uint64 instruction, img_address m_pc)
+static char *SEL_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("SEL.D %s, %s, %s", fd, fs, ft);
 }
@@ -13598,15 +13500,15 @@ static std::string SEL_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SEL_S(uint64 instruction, img_address m_pc)
+static char *SEL_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("SEL.S %s, %s, %s", fd, fs, ft);
 }
@@ -13622,15 +13524,15 @@ static std::string SEL_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SELEQZ_D(uint64 instruction, img_address m_pc)
+static char *SELEQZ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("SELEQZ.D %s, %s, %s", fd, fs, ft);
 }
@@ -13646,15 +13548,15 @@ static std::string SELEQZ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SELEQZ_S(uint64 instruction, img_address m_pc)
+static char *SELEQZ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("SELEQZ.S %s, %s, %s", fd, fs, ft);
 }
@@ -13670,15 +13572,15 @@ static std::string SELEQZ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SELNEZ_D(uint64 instruction, img_address m_pc)
+static char *SELNEZ_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("SELNEZ.D %s, %s, %s", fd, fs, ft);
 }
@@ -13694,15 +13596,15 @@ static std::string SELNEZ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SELNEZ_S(uint64 instruction, img_address m_pc)
+static char *SELNEZ_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("SELNEZ.S %s, %s, %s", fd, fs, ft);
 }
@@ -13718,15 +13620,15 @@ static std::string SELNEZ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SEQI(uint64 instruction, img_address m_pc)
+static char *SEQI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SEQI %s, %s, %s", rt, rs, u);
 }
@@ -13742,15 +13644,15 @@ static std::string SEQI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SH_16_(uint64 instruction, img_address m_pc)
+static char *SH_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_2_1__s1(instruction);
 
-    std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("SH %s, %s(%s)", rtz3, u, rs3);
 }
@@ -13766,13 +13668,13 @@ static std::string SH_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SH_GP_(uint64 instruction, img_address m_pc)
+static char *SH_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SH %s, %s($%d)", rt, u, 28);
 }
@@ -13788,15 +13690,15 @@ static std::string SH_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SH_S9_(uint64 instruction, img_address m_pc)
+static char *SH_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SH %s, %s(%s)", rt, s, rs);
 }
@@ -13812,15 +13714,15 @@ static std::string SH_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SH_U12_(uint64 instruction, img_address m_pc)
+static char *SH_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SH %s, %s(%s)", rt, u, rs);
 }
@@ -13836,15 +13738,15 @@ static std::string SH_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHE(uint64 instruction, img_address m_pc)
+static char *SHE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHE %s, %s(%s)", rt, s, rs);
 }
@@ -13860,13 +13762,13 @@ static std::string SHE(uint64 instruction, img_address m_pc)
  *      shift ------
  *               ac --
  */
-static std::string SHILO(uint64 instruction, img_address m_pc)
+static char *SHILO(uint64 instruction, img_address m_pc)
 {
     int64 shift_value = extract_shift__se5_21_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string shift = IMMEDIATE(copy(shift_value));
-    std::string ac = AC(copy(ac_value));
+    char *shift = IMMEDIATE(copy(shift_value));
+    const char *ac = AC(copy(ac_value));
 
     return img_format("SHILO %s, %s", ac, shift);
 }
@@ -13882,13 +13784,13 @@ static std::string SHILO(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static std::string SHILOV(uint64 instruction, img_address m_pc)
+static char *SHILOV(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string ac = AC(copy(ac_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *ac = AC(copy(ac_value));
 
     return img_format("SHILOV %s, %s", ac, rs);
 }
@@ -13904,15 +13806,15 @@ static std::string SHILOV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ----
  */
-static std::string SHLL_PH(uint64 instruction, img_address m_pc)
+static char *SHLL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHLL.PH %s, %s, %s", rt, rs, sa);
 }
@@ -13928,15 +13830,15 @@ static std::string SHLL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ---
  */
-static std::string SHLL_QB(uint64 instruction, img_address m_pc)
+static char *SHLL_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHLL.QB %s, %s, %s", rt, rs, sa);
 }
@@ -13953,15 +13855,15 @@ static std::string SHLL_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ----
  */
-static std::string SHLL_S_PH(uint64 instruction, img_address m_pc)
+static char *SHLL_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
 }
@@ -13977,15 +13879,15 @@ static std::string SHLL_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa -----
  */
-static std::string SHLL_S_W(uint64 instruction, img_address m_pc)
+static char *SHLL_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHLL_S.W %s, %s, %s", rt, rs, sa);
 }
@@ -14002,15 +13904,15 @@ static std::string SHLL_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHLLV_PH(uint64 instruction, img_address m_pc)
+static char *SHLLV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHLLV.PH %s, %s, %s", rd, rt, rs);
 }
@@ -14026,15 +13928,15 @@ static std::string SHLLV_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHLLV_QB(uint64 instruction, img_address m_pc)
+static char *SHLLV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHLLV.QB %s, %s, %s", rd, rt, rs);
 }
@@ -14051,15 +13953,15 @@ static std::string SHLLV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHLLV_S_PH(uint64 instruction, img_address m_pc)
+static char *SHLLV_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
 }
@@ -14075,15 +13977,15 @@ static std::string SHLLV_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHLLV_S_W(uint64 instruction, img_address m_pc)
+static char *SHLLV_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
 }
@@ -14099,15 +14001,15 @@ static std::string SHLLV_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRA_PH(uint64 instruction, img_address m_pc)
+static char *SHRA_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRA.PH %s, %s, %s", rt, rs, sa);
 }
@@ -14123,15 +14025,15 @@ static std::string SHRA_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRA_QB(uint64 instruction, img_address m_pc)
+static char *SHRA_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRA.QB %s, %s, %s", rt, rs, sa);
 }
@@ -14147,15 +14049,15 @@ static std::string SHRA_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRA_R_PH(uint64 instruction, img_address m_pc)
+static char *SHRA_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
 }
@@ -14171,15 +14073,15 @@ static std::string SHRA_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRA_R_QB(uint64 instruction, img_address m_pc)
+static char *SHRA_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
 }
@@ -14195,15 +14097,15 @@ static std::string SHRA_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRA_R_W(uint64 instruction, img_address m_pc)
+static char *SHRA_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRA_R.W %s, %s, %s", rt, rs, sa);
 }
@@ -14219,15 +14121,15 @@ static std::string SHRA_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRAV_PH(uint64 instruction, img_address m_pc)
+static char *SHRAV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHRAV.PH %s, %s, %s", rd, rt, rs);
 }
@@ -14243,15 +14145,15 @@ static std::string SHRAV_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRAV_QB(uint64 instruction, img_address m_pc)
+static char *SHRAV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHRAV.QB %s, %s, %s", rd, rt, rs);
 }
@@ -14267,15 +14169,15 @@ static std::string SHRAV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRAV_R_PH(uint64 instruction, img_address m_pc)
+static char *SHRAV_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
 }
@@ -14291,15 +14193,15 @@ static std::string SHRAV_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRAV_R_QB(uint64 instruction, img_address m_pc)
+static char *SHRAV_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
 }
@@ -14315,15 +14217,15 @@ static std::string SHRAV_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRAV_R_W(uint64 instruction, img_address m_pc)
+static char *SHRAV_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
 }
@@ -14339,15 +14241,15 @@ static std::string SHRAV_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ----
  */
-static std::string SHRL_PH(uint64 instruction, img_address m_pc)
+static char *SHRL_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRL.PH %s, %s, %s", rt, rs, sa);
 }
@@ -14363,15 +14265,15 @@ static std::string SHRL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ---
  */
-static std::string SHRL_QB(uint64 instruction, img_address m_pc)
+static char *SHRL_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRL.QB %s, %s, %s", rt, rs, sa);
 }
@@ -14388,15 +14290,15 @@ static std::string SHRL_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRLV_PH(uint64 instruction, img_address m_pc)
+static char *SHRLV_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHRLV.PH %s, %s, %s", rd, rt, rs);
 }
@@ -14412,15 +14314,15 @@ static std::string SHRLV_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHRLV_QB(uint64 instruction, img_address m_pc)
+static char *SHRLV_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SHRLV.QB %s, %s, %s", rd, rt, rs);
 }
@@ -14436,15 +14338,15 @@ static std::string SHRLV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHX(uint64 instruction, img_address m_pc)
+static char *SHX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SHX %s, %s(%s)", rd, rs, rt);
 }
@@ -14460,15 +14362,15 @@ static std::string SHX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SHXS(uint64 instruction, img_address m_pc)
+static char *SHXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SHXS %s, %s(%s)", rd, rs, rt);
 }
@@ -14484,11 +14386,11 @@ static std::string SHXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SIGRIE(uint64 instruction, img_address m_pc)
+static char *SIGRIE(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
-    std::string code = IMMEDIATE(copy(code_value));
+    char *code = IMMEDIATE(copy(code_value));
 
     return img_format("SIGRIE %s", code);
 }
@@ -14504,15 +14406,15 @@ static std::string SIGRIE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SLL_16_(uint64 instruction, img_address m_pc)
+static char *SLL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 shift3_value = extract_shift3_2_1_0(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    char *shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
 
     return img_format("SLL %s, %s, %s", rt3, rs3, shift3);
 }
@@ -14528,15 +14430,15 @@ static std::string SLL_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SLL_32_(uint64 instruction, img_address m_pc)
+static char *SLL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("SLL %s, %s, %s", rt, rs, shift);
 }
@@ -14552,15 +14454,15 @@ static std::string SLL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SLLV(uint64 instruction, img_address m_pc)
+static char *SLLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SLLV %s, %s, %s", rd, rs, rt);
 }
@@ -14576,15 +14478,15 @@ static std::string SLLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SLT(uint64 instruction, img_address m_pc)
+static char *SLT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SLT %s, %s, %s", rd, rs, rt);
 }
@@ -14600,15 +14502,15 @@ static std::string SLT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SLTI(uint64 instruction, img_address m_pc)
+static char *SLTI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SLTI %s, %s, %s", rt, rs, u);
 }
@@ -14624,15 +14526,15 @@ static std::string SLTI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SLTIU(uint64 instruction, img_address m_pc)
+static char *SLTIU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SLTIU %s, %s, %s", rt, rs, u);
 }
@@ -14648,15 +14550,15 @@ static std::string SLTIU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SLTU(uint64 instruction, img_address m_pc)
+static char *SLTU(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SLTU %s, %s, %s", rd, rs, rt);
 }
@@ -14672,15 +14574,15 @@ static std::string SLTU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SOV(uint64 instruction, img_address m_pc)
+static char *SOV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SOV %s, %s, %s", rd, rs, rt);
 }
@@ -14696,11 +14598,11 @@ static std::string SOV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SPECIAL2(uint64 instruction, img_address m_pc)
+static char *SPECIAL2(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
-    std::string op = IMMEDIATE(copy(op_value));
+    char *op = IMMEDIATE(copy(op_value));
 
     return img_format("SPECIAL2 %s", op);
 }
@@ -14716,13 +14618,13 @@ static std::string SPECIAL2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SQRT_D(uint64 instruction, img_address m_pc)
+static char *SQRT_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("SQRT.D %s, %s", ft, fs);
 }
@@ -14738,13 +14640,13 @@ static std::string SQRT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SQRT_S(uint64 instruction, img_address m_pc)
+static char *SQRT_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("SQRT.S %s, %s", ft, fs);
 }
@@ -14760,15 +14662,15 @@ static std::string SQRT_S(uint64 instruction, img_address m_pc)
  *               rd -----
  *                    sa -----
  */
-static std::string SRA(uint64 instruction, img_address m_pc)
+static char *SRA(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("SRA %s, %s, %s", rt, rs, shift);
 }
@@ -14784,15 +14686,15 @@ static std::string SRA(uint64 instruction, img_address m_pc)
  *          rt -----
  *               rd -----
  */
-static std::string SRAV(uint64 instruction, img_address m_pc)
+static char *SRAV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SRAV %s, %s, %s", rd, rs, rt);
 }
@@ -14808,15 +14710,15 @@ static std::string SRAV(uint64 instruction, img_address m_pc)
  *          rt -----
  *               rd -----
  */
-static std::string SRL_16_(uint64 instruction, img_address m_pc)
+static char *SRL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 shift3_value = extract_shift3_2_1_0(instruction);
 
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    std::string shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    char *shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
 
     return img_format("SRL %s, %s, %s", rt3, rs3, shift3);
 }
@@ -14832,15 +14734,15 @@ static std::string SRL_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SRL_32_(uint64 instruction, img_address m_pc)
+static char *SRL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("SRL %s, %s, %s", rt, rs, shift);
 }
@@ -14856,15 +14758,15 @@ static std::string SRL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SRLV(uint64 instruction, img_address m_pc)
+static char *SRLV(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SRLV %s, %s, %s", rd, rs, rt);
 }
@@ -14880,15 +14782,15 @@ static std::string SRLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUB(uint64 instruction, img_address m_pc)
+static char *SUB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUB %s, %s, %s", rd, rs, rt);
 }
@@ -14904,15 +14806,15 @@ static std::string SUB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUB_D(uint64 instruction, img_address m_pc)
+static char *SUB_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("SUB.D %s, %s, %s", fd, fs, ft);
 }
@@ -14928,15 +14830,15 @@ static std::string SUB_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUB_S(uint64 instruction, img_address m_pc)
+static char *SUB_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    std::string fd = FPR(copy(fd_value));
-    std::string fs = FPR(copy(fs_value));
-    std::string ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
 
     return img_format("SUB.S %s, %s, %s", fd, fs, ft);
 }
@@ -14952,15 +14854,15 @@ static std::string SUB_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBQ_PH(uint64 instruction, img_address m_pc)
+static char *SUBQ_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBQ.PH %s, %s, %s", rd, rs, rt);
 }
@@ -14977,15 +14879,15 @@ static std::string SUBQ_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBQ_S_PH(uint64 instruction, img_address m_pc)
+static char *SUBQ_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -15002,15 +14904,15 @@ static std::string SUBQ_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBQ_S_W(uint64 instruction, img_address m_pc)
+static char *SUBQ_S_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
 }
@@ -15027,15 +14929,15 @@ static std::string SUBQ_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBQH_PH(uint64 instruction, img_address m_pc)
+static char *SUBQH_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBQH.PH %s, %s, %s", rd, rs, rt);
 }
@@ -15052,15 +14954,15 @@ static std::string SUBQH_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBQH_R_PH(uint64 instruction, img_address m_pc)
+static char *SUBQH_R_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
 }
@@ -15077,15 +14979,15 @@ static std::string SUBQH_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBQH_R_W(uint64 instruction, img_address m_pc)
+static char *SUBQH_R_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
 }
@@ -15102,15 +15004,15 @@ static std::string SUBQH_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBQH_W(uint64 instruction, img_address m_pc)
+static char *SUBQH_W(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBQH.W %s, %s, %s", rd, rs, rt);
 }
@@ -15126,15 +15028,15 @@ static std::string SUBQH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBU_16_(uint64 instruction, img_address m_pc)
+static char *SUBU_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 rd3_value = extract_rd3_3_2_1(instruction);
 
-    std::string rd3 = GPR(decode_gpr_gpr3(rd3_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rd3 = GPR(decode_gpr_gpr3(rd3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
 
     return img_format("SUBU %s, %s, %s", rd3, rs3, rt3);
 }
@@ -15150,15 +15052,15 @@ static std::string SUBU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBU_32_(uint64 instruction, img_address m_pc)
+static char *SUBU_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBU %s, %s, %s", rd, rs, rt);
 }
@@ -15174,15 +15076,15 @@ static std::string SUBU_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBU_PH(uint64 instruction, img_address m_pc)
+static char *SUBU_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBU.PH %s, %s, %s", rd, rs, rt);
 }
@@ -15198,15 +15100,15 @@ static std::string SUBU_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBU_QB(uint64 instruction, img_address m_pc)
+static char *SUBU_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBU.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15223,15 +15125,15 @@ static std::string SUBU_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBU_S_PH(uint64 instruction, img_address m_pc)
+static char *SUBU_S_PH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -15248,15 +15150,15 @@ static std::string SUBU_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBU_S_QB(uint64 instruction, img_address m_pc)
+static char *SUBU_S_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15273,15 +15175,15 @@ static std::string SUBU_S_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBUH_QB(uint64 instruction, img_address m_pc)
+static char *SUBUH_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBUH.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15298,15 +15200,15 @@ static std::string SUBUH_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SUBUH_R_QB(uint64 instruction, img_address m_pc)
+static char *SUBUH_R_QB(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15322,15 +15224,15 @@ static std::string SUBUH_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SW_16_(uint64 instruction, img_address m_pc)
+static char *SW_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_3_2_1_0__s2(instruction);
 
-    std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("SW %s, %s(%s)", rtz3, u, rs3);
 }
@@ -15346,15 +15248,15 @@ static std::string SW_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SW_4X4_(uint64 instruction, img_address m_pc)
+static char *SW_4X4_(uint64 instruction, img_address m_pc)
 {
     uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
     uint64 u_value = extract_u_3_8__s2(instruction);
 
-    std::string rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs4 = GPR(decode_gpr_gpr4(rs4_value));
+    const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
 
     return img_format("SW %s, %s(%s)", rtz4, u, rs4);
 }
@@ -15370,13 +15272,13 @@ static std::string SW_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SW_GP16_(uint64 instruction, img_address m_pc)
+static char *SW_GP16_(uint64 instruction, img_address m_pc)
 {
     uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
 
-    std::string rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SW %s, %s($%d)", rtz3, u, 28);
 }
@@ -15392,13 +15294,13 @@ static std::string SW_GP16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SW_GP_(uint64 instruction, img_address m_pc)
+static char *SW_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SW %s, %s($%d)", rt, u, 28);
 }
@@ -15414,15 +15316,15 @@ static std::string SW_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SW_S9_(uint64 instruction, img_address m_pc)
+static char *SW_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SW %s, %s(%s)", rt, s, rs);
 }
@@ -15438,13 +15340,13 @@ static std::string SW_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SW_SP_(uint64 instruction, img_address m_pc)
+static char *SW_SP_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SW %s, %s($%d)", rt, u, 29);
 }
@@ -15460,15 +15362,15 @@ static std::string SW_SP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SW_U12_(uint64 instruction, img_address m_pc)
+static char *SW_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SW %s, %s(%s)", rt, u, rs);
 }
@@ -15484,13 +15386,13 @@ static std::string SW_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SWC1_GP_(uint64 instruction, img_address m_pc)
+static char *SWC1_GP_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *ft = FPR(copy(ft_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SWC1 %s, %s($%d)", ft, u, 28);
 }
@@ -15506,15 +15408,15 @@ static std::string SWC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SWC1_S9_(uint64 instruction, img_address m_pc)
+static char *SWC1_S9_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy(ft_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SWC1 %s, %s(%s)", ft, s, rs);
 }
@@ -15530,15 +15432,15 @@ static std::string SWC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SWC1_U12_(uint64 instruction, img_address m_pc)
+static char *SWC1_U12_(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string u = IMMEDIATE(copy(u_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy(ft_value));
+    char *u = IMMEDIATE(copy(u_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SWC1 %s, %s(%s)", ft, u, rs);
 }
@@ -15554,15 +15456,15 @@ static std::string SWC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SWC1X(uint64 instruction, img_address m_pc)
+static char *SWC1X(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SWC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -15578,15 +15480,15 @@ static std::string SWC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SWC1XS(uint64 instruction, img_address m_pc)
+static char *SWC1XS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SWC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -15602,15 +15504,15 @@ static std::string SWC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SWC2(uint64 instruction, img_address m_pc)
+static char *SWC2(uint64 instruction, img_address m_pc)
 {
     uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string cs = CPR(copy(cs_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *cs = CPR(copy(cs_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SWC2 %s, %s(%s)", cs, s, rs);
 }
@@ -15626,15 +15528,15 @@ static std::string SWC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SWE(uint64 instruction, img_address m_pc)
+static char *SWE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SWE %s, %s(%s)", rt, s, rs);
 }
@@ -15650,17 +15552,17 @@ static std::string SWE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SWM(uint64 instruction, img_address m_pc)
+static char *SWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
+    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("SWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -15676,13 +15578,13 @@ static std::string SWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SWPC_48_(uint64 instruction, img_address m_pc)
+static char *SWPC_48_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    const char *rt = GPR(copy(rt_value));
+    char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("SWPC %s, %s", rt, s);
 }
@@ -15698,15 +15600,15 @@ static std::string SWPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SWX(uint64 instruction, img_address m_pc)
+static char *SWX(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SWX %s, %s(%s)", rd, rs, rt);
 }
@@ -15722,15 +15624,15 @@ static std::string SWX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SWXS(uint64 instruction, img_address m_pc)
+static char *SWXS(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("SWXS %s, %s(%s)", rd, rs, rt);
 }
@@ -15746,11 +15648,11 @@ static std::string SWXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SYNC(uint64 instruction, img_address m_pc)
+static char *SYNC(uint64 instruction, img_address m_pc)
 {
     uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
 
-    std::string stype = IMMEDIATE(copy(stype_value));
+    char *stype = IMMEDIATE(copy(stype_value));
 
     return img_format("SYNC %s", stype);
 }
@@ -15766,13 +15668,13 @@ static std::string SYNC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SYNCI(uint64 instruction, img_address m_pc)
+static char *SYNCI(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SYNCI %s(%s)", s, rs);
 }
@@ -15788,13 +15690,13 @@ static std::string SYNCI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SYNCIE(uint64 instruction, img_address m_pc)
+static char *SYNCIE(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("SYNCIE %s(%s)", s, rs);
 }
@@ -15810,11 +15712,11 @@ static std::string SYNCIE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string SYSCALL_16_(uint64 instruction, img_address m_pc)
+static char *SYSCALL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
-    std::string code = IMMEDIATE(copy(code_value));
+    char *code = IMMEDIATE(copy(code_value));
 
     return img_format("SYSCALL %s", code);
 }
@@ -15828,11 +15730,11 @@ static std::string SYSCALL_16_(uint64 instruction, img_address m_pc)
  *  00000000000010
  *           code ------------------
  */
-static std::string SYSCALL_32_(uint64 instruction, img_address m_pc)
+static char *SYSCALL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
-    std::string code = IMMEDIATE(copy(code_value));
+    char *code = IMMEDIATE(copy(code_value));
 
     return img_format("SYSCALL %s", code);
 }
@@ -15848,13 +15750,13 @@ static std::string SYSCALL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TEQ(uint64 instruction, img_address m_pc)
+static char *TEQ(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("TEQ %s, %s", rs, rt);
 }
@@ -15870,11 +15772,11 @@ static std::string TEQ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBGINV(uint64 instruction, img_address m_pc)
+static char *TLBGINV(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBGINV ";
+    return (char *)"TLBGINV ";
 }
 
 
@@ -15888,11 +15790,11 @@ static std::string TLBGINV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBGINVF(uint64 instruction, img_address m_pc)
+static char *TLBGINVF(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBGINVF ";
+    return (char *)"TLBGINVF ";
 }
 
 
@@ -15906,11 +15808,11 @@ static std::string TLBGINVF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBGP(uint64 instruction, img_address m_pc)
+static char *TLBGP(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBGP ";
+    return (char *)"TLBGP ";
 }
 
 
@@ -15924,11 +15826,11 @@ static std::string TLBGP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBGR(uint64 instruction, img_address m_pc)
+static char *TLBGR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBGR ";
+    return (char *)"TLBGR ";
 }
 
 
@@ -15942,11 +15844,11 @@ static std::string TLBGR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBGWI(uint64 instruction, img_address m_pc)
+static char *TLBGWI(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBGWI ";
+    return (char *)"TLBGWI ";
 }
 
 
@@ -15960,11 +15862,11 @@ static std::string TLBGWI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBGWR(uint64 instruction, img_address m_pc)
+static char *TLBGWR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBGWR ";
+    return (char *)"TLBGWR ";
 }
 
 
@@ -15978,11 +15880,11 @@ static std::string TLBGWR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBINV(uint64 instruction, img_address m_pc)
+static char *TLBINV(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBINV ";
+    return (char *)"TLBINV ";
 }
 
 
@@ -15996,11 +15898,11 @@ static std::string TLBINV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBINVF(uint64 instruction, img_address m_pc)
+static char *TLBINVF(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBINVF ";
+    return (char *)"TLBINVF ";
 }
 
 
@@ -16014,11 +15916,11 @@ static std::string TLBINVF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBP(uint64 instruction, img_address m_pc)
+static char *TLBP(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBP ";
+    return (char *)"TLBP ";
 }
 
 
@@ -16032,11 +15934,11 @@ static std::string TLBP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBR(uint64 instruction, img_address m_pc)
+static char *TLBR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBR ";
+    return (char *)"TLBR ";
 }
 
 
@@ -16050,11 +15952,11 @@ static std::string TLBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBWI(uint64 instruction, img_address m_pc)
+static char *TLBWI(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBWI ";
+    return (char *)"TLBWI ";
 }
 
 
@@ -16068,11 +15970,11 @@ static std::string TLBWI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TLBWR(uint64 instruction, img_address m_pc)
+static char *TLBWR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return "TLBWR ";
+    return (char *)"TLBWR ";
 }
 
 
@@ -16086,13 +15988,13 @@ static std::string TLBWR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TNE(uint64 instruction, img_address m_pc)
+static char *TNE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("TNE %s, %s", rs, rt);
 }
@@ -16108,13 +16010,13 @@ static std::string TNE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TRUNC_L_D(uint64 instruction, img_address m_pc)
+static char *TRUNC_L_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("TRUNC.L.D %s, %s", ft, fs);
 }
@@ -16130,13 +16032,13 @@ static std::string TRUNC_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TRUNC_L_S(uint64 instruction, img_address m_pc)
+static char *TRUNC_L_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("TRUNC.L.S %s, %s", ft, fs);
 }
@@ -16152,13 +16054,13 @@ static std::string TRUNC_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TRUNC_W_D(uint64 instruction, img_address m_pc)
+static char *TRUNC_W_D(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("TRUNC.W.D %s, %s", ft, fs);
 }
@@ -16174,13 +16076,13 @@ static std::string TRUNC_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string TRUNC_W_S(uint64 instruction, img_address m_pc)
+static char *TRUNC_W_S(uint64 instruction, img_address m_pc)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    std::string ft = FPR(copy(ft_value));
-    std::string fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy(ft_value));
+    const char *fs = FPR(copy(fs_value));
 
     return img_format("TRUNC.W.S %s, %s", ft, fs);
 }
@@ -16196,17 +16098,17 @@ static std::string TRUNC_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string UALDM(uint64 instruction, img_address m_pc)
+static char *UALDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
+    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16222,15 +16124,15 @@ static std::string UALDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string UALH(uint64 instruction, img_address m_pc)
+static char *UALH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("UALH %s, %s(%s)", rt, s, rs);
 }
@@ -16246,17 +16148,17 @@ static std::string UALH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string UALWM(uint64 instruction, img_address m_pc)
+static char *UALWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
+    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16272,17 +16174,17 @@ static std::string UALWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string UASDM(uint64 instruction, img_address m_pc)
+static char *UASDM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
+    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16298,15 +16200,15 @@ static std::string UASDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string UASH(uint64 instruction, img_address m_pc)
+static char *UASH(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("UASH %s, %s(%s)", rt, s, rs);
 }
@@ -16322,17 +16224,17 @@ static std::string UASH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string UASWM(uint64 instruction, img_address m_pc)
+static char *UASWM(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string s = IMMEDIATE(copy(s_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy(rt_value));
+    char *s = IMMEDIATE(copy(s_value));
+    const char *rs = GPR(copy(rs_value));
+    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16348,11 +16250,11 @@ static std::string UASWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string UDI(uint64 instruction, img_address m_pc)
+static char *UDI(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
-    std::string op = IMMEDIATE(copy(op_value));
+    char *op = IMMEDIATE(copy(op_value));
 
     return img_format("UDI %s", op);
 }
@@ -16366,11 +16268,11 @@ static std::string UDI(uint64 instruction, img_address m_pc)
  *  001000          1100001101111111
  *   code ----------
  */
-static std::string WAIT(uint64 instruction, img_address m_pc)
+static char *WAIT(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
 
-    std::string code = IMMEDIATE(copy(code_value));
+    char *code = IMMEDIATE(copy(code_value));
 
     return img_format("WAIT %s", code);
 }
@@ -16386,13 +16288,13 @@ static std::string WAIT(uint64 instruction, img_address m_pc)
  *     rt -----
  *        mask -------
  */
-static std::string WRDSP(uint64 instruction, img_address m_pc)
+static char *WRDSP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string mask = IMMEDIATE(copy(mask_value));
+    const char *rt = GPR(copy(rt_value));
+    char *mask = IMMEDIATE(copy(mask_value));
 
     return img_format("WRDSP %s, %s", rt, mask);
 }
@@ -16408,13 +16310,13 @@ static std::string WRDSP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string WRPGPR(uint64 instruction, img_address m_pc)
+static char *WRPGPR(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("WRPGPR %s, %s", rt, rs);
 }
@@ -16430,13 +16332,13 @@ static std::string WRPGPR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string XOR_16_(uint64 instruction, img_address m_pc)
+static char *XOR_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
 
-    std::string rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    std::string rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
 
     return img_format("XOR %s, %s", rs3, rt3);
 }
@@ -16452,15 +16354,15 @@ static std::string XOR_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string XOR_32_(uint64 instruction, img_address m_pc)
+static char *XOR_32_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    std::string rd = GPR(copy(rd_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy(rd_value));
+    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
 
     return img_format("XOR %s, %s, %s", rd, rs, rt);
 }
@@ -16476,15 +16378,15 @@ static std::string XOR_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static std::string XORI(uint64 instruction, img_address m_pc)
+static char *XORI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
-    std::string u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
+    char *u = IMMEDIATE(copy(u_value));
 
     return img_format("XORI %s, %s, %s", rt, rs, u);
 }
@@ -16499,13 +16401,13 @@ static std::string XORI(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static std::string YIELD(uint64 instruction, img_address m_pc)
+static char *YIELD(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    std::string rt = GPR(copy(rt_value));
-    std::string rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy(rs_value));
 
     return img_format("YIELD %s, %s", rt, rs);
 }
@@ -22308,7 +22210,7 @@ static struct Pool MAJOR[2] = {
        0x0                 },        /* P16 */
 };
 
-static int Disassemble(const uint16 *data, std::string & dis,
+static int Disassemble(const uint16 *data, char *dis,
                        TABLE_ENTRY_TYPE & type, img_address m_pc)
 {
     return Disassemble(data, dis, type, MAJOR, 2, m_pc);
@@ -22320,13 +22222,13 @@ static int nanomips_dis(char *buf,
                  unsigned short two,
                  unsigned short three)
 {
-    std::string disasm;
+    char disasm[200];
     uint16 bits[3] = {one, two, three};
 
     TABLE_ENTRY_TYPE type;
     int size = Disassemble(bits, disasm, type, address);
 
-    strcpy(buf, disasm.c_str());
+    strcpy(buf, disasm);
     return size;
 }
 
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 12/20] disas/nanomips: Replace std::string type
  2022-09-05  9:55 ` [PATCH v2 12/20] disas/nanomips: Replace std::string type Milica Lazarevic
@ 2022-09-05 11:32   ` Richard Henderson
  2022-09-08 19:16     ` Milica Lazarevic
  0 siblings, 1 reply; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:32 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> -static std::string save_restore_list(uint64 rt, uint64 count, uint64 gp)
> +static char *save_restore_list(uint64 rt, uint64 count, uint64 gp)
>   {
> -    std::string str;
> +    /*
> +     * Currently, this file compiles as a cpp file, so the explicit cast here
> +     * is necessary. Later, the cast will be removed.
> +     */
> +    char *str = (char *)g_malloc(200);
> +    str[0] = '\0';
>   
>       for (uint64 counter = 0; counter != count; counter++) {
>           bool use_gp = gp && (counter == count - 1);
>           uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
> -        str += img_format(",%s", GPR(this_rt));
> +        strcat(str, img_format(",%s", GPR(this_rt)));
>       }
>   
>       return str;
>   }

This would be better written as

     char *reg_list[33];

     assert(count <= 32);
     for (c = 0; c < count; c++) {
         bool use_gp = ...
         uint64 this_rt = ...
         /* glib usage below requires casting away const */
         reg_list[c] = (char *)GPR(this_rt);
     }
     reg_list[count] = NULL;

     return g_strjoinv(",", reg_list);



> @@ -716,7 +617,7 @@ static uint64 extract_op_code_value(const uint16 *data, int size)
>    *      instruction size    - negative is error
>    *      disassembly string  - on error will constain error string
>    */
> -static int Disassemble(const uint16 *data, std::string & dis,
> +static int Disassemble(const uint16 *data, char *dis,


I think this interface should be

     char **dis,

so that...

> @@ -746,25 +647,26 @@ static int Disassemble(const uint16 *data, std::string & dis,
>                                    * an ASE attribute and the requested version
>                                    * not having that attribute
>                                    */
> -                                dis = "ASE attribute mismatch";
> +                                strcpy(dis, "ASE attribute mismatch");

these become

     *dis = g_strdup("string");

and the usage in nanomips_dis does not assume a fixed sized buffer.


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 12/20] disas/nanomips: Replace std::string type
  2022-09-05 11:32   ` Richard Henderson
@ 2022-09-08 19:16     ` Milica Lazarevic
  2022-09-08 21:14       ` Richard Henderson
  0 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-08 19:16 UTC (permalink / raw)
  To: Richard Henderson, thuth@redhat.com
  Cc: qemu-devel@nongnu.org, cfontana@suse.de, berrange@redhat.com,
	pbonzini@redhat.com, vince.delvecchio@mediatek.com,
	peter.maydell@linaro.org, Djordje Todorovic, mips32r2@gmail.com,
	Dragan Mladjenovic

[-- Attachment #1: Type: text/plain, Size: 2992 bytes --]


On 9/5/22 10:55, Milica Lazarevic wrote:
> -static std::string save_restore_list(uint64 rt, uint64 count, uint64 gp)
> +static char *save_restore_list(uint64 rt, uint64 count, uint64 gp)
>   {
> -    std::string str;
> +    /*
> +     * Currently, this file compiles as a cpp file, so the explicit cast here
> +     * is necessary. Later, the cast will be removed.
> +     */
> +    char *str = (char *)g_malloc(200);
> +    str[0] = '\0';
>
>       for (uint64 counter = 0; counter != count; counter++) {
>           bool use_gp = gp && (counter == count - 1);
>           uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
> -        str += img_format(",%s", GPR(this_rt));
> +        strcat(str, img_format(",%s", GPR(this_rt)));
>       }
>
>       return str;
>   }

This would be better written as

     char *reg_list[33];

     assert(count <= 32);
     for (c = 0; c < count; c++) {
         bool use_gp = ...
         uint64 this_rt = ...
         /* glib usage below requires casting away const */
         reg_list[c] = (char *)GPR(this_rt);
     }
     reg_list[count] = NULL;

     return g_strjoinv(",", reg_list);

In the implementation you suggested, there's one comma missing in the output.
For example, instead of having:
  > 0x802021ce: 1e12 SAVE 0x10,ra,s0
We're having this:
  < 0x802021ce: 1e12 SAVE 0x10ra,s0
So, I'm assuming that there needs to exist one more concatenation between the comma and the result of the g_strjoinv function?
Maybe something like
    return g_strconcat((char *)",", (char *)g_strjoinv(",", reg_list), NULL);
this?

Would it be acceptable to go with a similar implementation as in the patch, but without a call to img_format and with the g_strconcat instead of the strcat function?

> @@ -716,7 +617,7 @@ static uint64 extract_op_code_value(const uint16 *data, int size)
>    *      instruction size    - negative is error
>    *      disassembly string  - on error will constain error string
>    */
> -static int Disassemble(const uint16 *data, std::string & dis,
> +static int Disassemble(const uint16 *data, char *dis,


I think this interface should be

     char **dis,

so that...

> @@ -746,25 +647,26 @@ static int Disassemble(const uint16 *data, std::string & dis,
>                                    * an ASE attribute and the requested version
>                                    * not having that attribute
>                                    */
> -                                dis = "ASE attribute mismatch";
> +                                strcpy(dis, "ASE attribute mismatch");

these become

     *dis = g_strdup("string");

and the usage in nanomips_dis does not assume a fixed sized buffer.


r~

I'm not sure why the fixed size buffer would be a problem here since the buffer size has already been limited by the caller.
I.e. in the print_insn_nanomips function, the buf variable is defined as:
char buf[200];

[-- Attachment #2: Type: text/html, Size: 6464 bytes --]

^ permalink raw reply	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 12/20] disas/nanomips: Replace std::string type
  2022-09-08 19:16     ` Milica Lazarevic
@ 2022-09-08 21:14       ` Richard Henderson
  2022-09-08 21:46         ` Milica Lazarevic
  0 siblings, 1 reply; 46+ messages in thread
From: Richard Henderson @ 2022-09-08 21:14 UTC (permalink / raw)
  To: Milica Lazarevic, thuth@redhat.com
  Cc: qemu-devel@nongnu.org, cfontana@suse.de, berrange@redhat.com,
	pbonzini@redhat.com, vince.delvecchio@mediatek.com,
	peter.maydell@linaro.org, Djordje Todorovic, mips32r2@gmail.com,
	Dragan Mladjenovic

On 9/8/22 20:16, Milica Lazarevic wrote:
>     This would be better written as
> 
>           char *reg_list[33];
> 
>           assert(count <= 32);
>           for (c = 0; c < count; c++) {
>               bool use_gp = ...
>               uint64 this_rt = ...
>               /* glib usage below requires casting away const */
>               reg_list[c] = (char *)GPR(this_rt);
>           }
>           reg_list[count] = NULL;
> 
>           return g_strjoinv(",", reg_list);
> 
> 
> In the implementation you suggested, there's one comma missing in the output.
> For example, instead of having:
>    > 0x802021ce: 1e12 SAVE 0x10,ra,s0
> We're having this:
>    < 0x802021ce: 1e12 SAVE 0x10ra,s0

Oh, right, because SAVE of zero registers is legal, and even useful as an adjustment to 
the stack pointer.

> So, I'm assuming that there needs to exist one more concatenation between the comma and 
> the result of the g_strjoinv function?
> Maybe something like
>      return g_strconcat((char *)",", (char *)g_strjoinv(",", reg_list), NULL);

Well, written like that you'd leak the result of g_strjoinv.

A better solution is to first element of reg_list be "", so that it's still just a single 
memory allocation.

>     I think this interface should be
> 
>           char **dis,
> 
>     so that...
> 
>     > @@ -746,25 +647,26 @@ static int Disassemble(const uint16 *data, std::string & dis,
>     >                                    * an ASE attribute and the requested version
>     >                                    * not having that attribute
>     >                                    */
>     > -                                dis = "ASE attribute mismatch";
>     > +                                strcpy(dis, "ASE attribute mismatch");
> 
>     these become
> 
>           *dis = g_strdup("string");
> 
>     and the usage in nanomips_dis does not assume a fixed sized buffer.
> 
> 
>     r~
> 
> 
> I'm not sure why the fixed size buffer would be a problem here since the buffer size has 
> already been limited by the caller.
> I.e. in the print_insn_nanomips function, the buf variable is defined as:
> char buf[200];

There would be no such declaration with the above change.


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 12/20] disas/nanomips: Replace std::string type
  2022-09-08 21:14       ` Richard Henderson
@ 2022-09-08 21:46         ` Milica Lazarevic
  0 siblings, 0 replies; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-08 21:46 UTC (permalink / raw)
  To: Richard Henderson, thuth@redhat.com
  Cc: qemu-devel@nongnu.org, cfontana@suse.de, berrange@redhat.com,
	pbonzini@redhat.com, vince.delvecchio@mediatek.com,
	peter.maydell@linaro.org, Djordje Todorovic, mips32r2@gmail.com,
	Dragan Mladjenovic

[-- Attachment #1: Type: text/plain, Size: 3071 bytes --]

Thanks, it's more clear to me now! I'll modify it in the next by the suggestions.
________________________________
From: Richard Henderson <richard.henderson@linaro.org>
Sent: Thursday, September 8, 2022 11:14 PM
To: Milica Lazarevic <Milica.Lazarevic@Syrmia.com>; thuth@redhat.com <thuth@redhat.com>
Cc: qemu-devel@nongnu.org <qemu-devel@nongnu.org>; cfontana@suse.de <cfontana@suse.de>; berrange@redhat.com <berrange@redhat.com>; pbonzini@redhat.com <pbonzini@redhat.com>; vince.delvecchio@mediatek.com <vince.delvecchio@mediatek.com>; peter.maydell@linaro.org <peter.maydell@linaro.org>; Djordje Todorovic <Djordje.Todorovic@syrmia.com>; mips32r2@gmail.com <mips32r2@gmail.com>; Dragan Mladjenovic <Dragan.Mladjenovic@syrmia.com>
Subject: Re: [PATCH v2 12/20] disas/nanomips: Replace std::string type

On 9/8/22 20:16, Milica Lazarevic wrote:
>     This would be better written as
>
>           char *reg_list[33];
>
>           assert(count <= 32);
>           for (c = 0; c < count; c++) {
>               bool use_gp = ...
>               uint64 this_rt = ...
>               /* glib usage below requires casting away const */
>               reg_list[c] = (char *)GPR(this_rt);
>           }
>           reg_list[count] = NULL;
>
>           return g_strjoinv(",", reg_list);
>
>
> In the implementation you suggested, there's one comma missing in the output.
> For example, instead of having:
>    > 0x802021ce: 1e12 SAVE 0x10,ra,s0
> We're having this:
>    < 0x802021ce: 1e12 SAVE 0x10ra,s0

Oh, right, because SAVE of zero registers is legal, and even useful as an adjustment to
the stack pointer.

> So, I'm assuming that there needs to exist one more concatenation between the comma and
> the result of the g_strjoinv function?
> Maybe something like
>      return g_strconcat((char *)",", (char *)g_strjoinv(",", reg_list), NULL);

Well, written like that you'd leak the result of g_strjoinv.

A better solution is to first element of reg_list be "", so that it's still just a single
memory allocation.

>     I think this interface should be
>
>           char **dis,
>
>     so that...
>
>     > @@ -746,25 +647,26 @@ static int Disassemble(const uint16 *data, std::string & dis,
>     >                                    * an ASE attribute and the requested version
>     >                                    * not having that attribute
>     >                                    */
>     > -                                dis = "ASE attribute mismatch";
>     > +                                strcpy(dis, "ASE attribute mismatch");
>
>     these become
>
>           *dis = g_strdup("string");
>
>     and the usage in nanomips_dis does not assume a fixed sized buffer.
>
>
>     r~
>
>
> I'm not sure why the fixed size buffer would be a problem here since the buffer size has
> already been limited by the caller.
> I.e. in the print_insn_nanomips function, the buf variable is defined as:
> char buf[200];

There would be no such declaration with the above change.

r~

[-- Attachment #2: Type: text/html, Size: 6158 bytes --]

^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 13/20] disas/nanomips: Prevent memory leaking
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (11 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 12/20] disas/nanomips: Replace std::string type Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:41   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 14/20] disas/nanomips: Remove function overloading Milica Lazarevic
                   ` (6 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

g_autofree attribute is added for every dynamically allocated string to
prevent memory leaking.

The implementation of the several functions that work with dynamically
allocated strings is slightly changed so we can add those attributes.

Almost every disassembly_function returns the result of the img_format()
function, which returns a dynamically allocated string. To be able to
free that string for every disassembly_function, a strdup() call is
added for a return value of some disassembly functions like TLBGINV,
TLBGINVF, TLBGP, etc.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
---
 disas/nanomips.cpp | 714 +++++++++++++++++++++++----------------------
 1 file changed, 361 insertions(+), 353 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index cfea95130d..473c202649 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -523,7 +523,8 @@ static char *save_restore_list(uint64 rt, uint64 count, uint64 gp)
     for (uint64 counter = 0; counter != count; counter++) {
         bool use_gp = gp && (counter == count - 1);
         uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
-        strcat(str, img_format(",%s", GPR(this_rt)));
+        g_autofree char *dis_str = img_format(",%s", GPR(this_rt));
+        strcat(str, dis_str);
     }
 
     return str;
@@ -657,7 +658,8 @@ static int Disassemble(const uint16 *data, char *dis,
                                 return -6;
                             }
                             type = table[i].type;
-                            strcpy(dis, dis_fn(op_code, m_pc));
+                            g_autofree char *dis_str = dis_fn(op_code, m_pc);
+                            strcpy(dis, dis_str);
                             return table[i].instructions_size;
                         } else {
                             strcpy(dis, "reserved instruction");
@@ -1727,8 +1729,8 @@ static char *ACLR(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *bit = IMMEDIATE(copy(bit_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *bit = IMMEDIATE(copy(bit_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("ACLR %s, %s(%s)", bit, s, rs);
@@ -1825,7 +1827,7 @@ static char *ADDIU_32_(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt, rs, u);
 }
@@ -1846,7 +1848,7 @@ static char *ADDIU_48_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
 
     return img_format("ADDIU %s, %s", rt, s);
 }
@@ -1867,7 +1869,7 @@ static char *ADDIU_GP48_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, s);
 }
@@ -1888,7 +1890,7 @@ static char *ADDIU_GP_B_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, u);
 }
@@ -1909,7 +1911,7 @@ static char *ADDIU_GP_W_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, u);
 }
@@ -1932,7 +1934,7 @@ static char *ADDIU_NEG_(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *u = IMMEDIATE(neg_copy(u_value));
+    g_autofree char *u = IMMEDIATE(neg_copy(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt, rs, u);
 }
@@ -1953,7 +1955,7 @@ static char *ADDIU_R1_SP_(uint64 instruction, img_address m_pc)
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt3, 29, u);
 }
@@ -1976,7 +1978,7 @@ static char *ADDIU_R2_(uint64 instruction, img_address m_pc)
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt3, rs3, u);
 }
@@ -1996,7 +1998,7 @@ static char *ADDIU_RS5_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se3_4_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
 
     return img_format("ADDIU %s, %s", rt, s);
 }
@@ -2018,7 +2020,7 @@ static char *ADDIUPC_32_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("ADDIUPC %s, %s", rt, s);
 }
@@ -2040,7 +2042,7 @@ static char *ADDIUPC_48_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("ADDIUPC %s, %s", rt, s);
 }
@@ -2498,7 +2500,7 @@ static char *ALUIPC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
 }
@@ -2566,7 +2568,7 @@ static char *ANDI_16_(uint64 instruction, img_address m_pc)
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    char *eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
+    g_autofree char *eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
 
     return img_format("ANDI %s, %s, %s", rt3, rs3, eu);
 }
@@ -2590,7 +2592,7 @@ static char *ANDI_32_(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ANDI %s, %s, %s", rt, rs, u);
 }
@@ -2614,7 +2616,7 @@ static char *APPEND(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("APPEND %s, %s, %s", rt, rs, sa);
 }
@@ -2636,8 +2638,8 @@ static char *ASET(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *bit = IMMEDIATE(copy(bit_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *bit = IMMEDIATE(copy(bit_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("ASET %s, %s(%s)", bit, s, rs);
@@ -2658,7 +2660,7 @@ static char *BALC_16_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
 
-    char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BALC %s", s);
 }
@@ -2678,7 +2680,7 @@ static char *BALC_32_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
 
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BALC %s", s);
 }
@@ -2723,8 +2725,8 @@ static char *BBEQZC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *bit = IMMEDIATE(copy(bit_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *bit = IMMEDIATE(copy(bit_value));
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BBEQZC %s, %s, %s", rt, bit, s);
 }
@@ -2747,8 +2749,8 @@ static char *BBNEZC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *bit = IMMEDIATE(copy(bit_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *bit = IMMEDIATE(copy(bit_value));
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BBNEZC %s, %s, %s", rt, bit, s);
 }
@@ -2768,7 +2770,7 @@ static char *BC_16_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
 
-    char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BC %s", s);
 }
@@ -2788,7 +2790,7 @@ static char *BC_32_(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
 
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC %s", s);
 }
@@ -2810,7 +2812,7 @@ static char *BC1EQZC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC1EQZC %s, %s", ft, s);
 }
@@ -2832,7 +2834,7 @@ static char *BC1NEZC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC1NEZC %s, %s", ft, s);
 }
@@ -2853,8 +2855,8 @@ static char *BC2EQZC(uint64 instruction, img_address m_pc)
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    char *ct = CPR(copy(ct_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *ct = CPR(copy(ct_value));
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC2EQZC %s, %s", ct, s);
 }
@@ -2875,8 +2877,8 @@ static char *BC2NEZC(uint64 instruction, img_address m_pc)
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    char *ct = CPR(copy(ct_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *ct = CPR(copy(ct_value));
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC2NEZC %s, %s", ct, s);
 }
@@ -2900,7 +2902,7 @@ static char *BEQC_16_(uint64 instruction, img_address m_pc)
 
     const char *rs3 = GPR(encode_rs3_and_check_rs3_lt_rt3(rs3_value));
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
+    g_autofree char *u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
 
     return img_format("BEQC %s, %s, %s", rs3, rt3, u);
 }
@@ -2924,7 +2926,7 @@ static char *BEQC_32_(uint64 instruction, img_address m_pc)
 
     const char *rs = GPR(copy(rs_value));
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BEQC %s, %s, %s", rs, rt, s);
 }
@@ -2947,8 +2949,8 @@ static char *BEQIC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BEQIC %s, %s, %s", rt, u, s);
 }
@@ -2970,7 +2972,7 @@ static char *BEQZC_16_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BEQZC %s, %s", rt3, s);
 }
@@ -2994,7 +2996,7 @@ static char *BGEC(uint64 instruction, img_address m_pc)
 
     const char *rs = GPR(copy(rs_value));
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEC %s, %s, %s", rs, rt, s);
 }
@@ -3017,8 +3019,8 @@ static char *BGEIC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEIC %s, %s, %s", rt, u, s);
 }
@@ -3041,8 +3043,8 @@ static char *BGEIUC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEIUC %s, %s, %s", rt, u, s);
 }
@@ -3066,7 +3068,7 @@ static char *BGEUC(uint64 instruction, img_address m_pc)
 
     const char *rs = GPR(copy(rs_value));
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEUC %s, %s, %s", rs, rt, s);
 }
@@ -3090,7 +3092,7 @@ static char *BLTC(uint64 instruction, img_address m_pc)
 
     const char *rs = GPR(copy(rs_value));
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTC %s, %s, %s", rs, rt, s);
 }
@@ -3113,8 +3115,8 @@ static char *BLTIC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTIC %s, %s, %s", rt, u, s);
 }
@@ -3137,8 +3139,8 @@ static char *BLTIUC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTIUC %s, %s, %s", rt, u, s);
 }
@@ -3162,7 +3164,7 @@ static char *BLTUC(uint64 instruction, img_address m_pc)
 
     const char *rs = GPR(copy(rs_value));
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTUC %s, %s, %s", rs, rt, s);
 }
@@ -3186,7 +3188,7 @@ static char *BNEC_16_(uint64 instruction, img_address m_pc)
 
     const char *rs3 = GPR(encode_rs3_and_check_rs3_ge_rt3(rs3_value));
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
+    g_autofree char *u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
 
     return img_format("BNEC %s, %s, %s", rs3, rt3, u);
 }
@@ -3210,7 +3212,7 @@ static char *BNEC_32_(uint64 instruction, img_address m_pc)
 
     const char *rs = GPR(copy(rs_value));
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BNEC %s, %s, %s", rs, rt, s);
 }
@@ -3233,8 +3235,8 @@ static char *BNEIC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BNEIC %s, %s, %s", rt, u, s);
 }
@@ -3256,7 +3258,7 @@ static char *BNEZC_16_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
 
     return img_format("BNEZC %s, %s", rt3, s);
 }
@@ -3276,7 +3278,7 @@ static char *BPOSGE32C(uint64 instruction, img_address m_pc)
 {
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BPOSGE32C %s", s);
 }
@@ -3296,7 +3298,7 @@ static char *BREAK_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
-    char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE(copy(code_value));
 
     return img_format("BREAK %s", code);
 }
@@ -3316,7 +3318,7 @@ static char *BREAK_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
-    char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE(copy(code_value));
 
     return img_format("BREAK %s", code);
 }
@@ -3358,8 +3360,8 @@ static char *CACHE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *op = IMMEDIATE(copy(op_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *op = IMMEDIATE(copy(op_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("CACHE %s, %s(%s)", op, s, rs);
@@ -3382,8 +3384,8 @@ static char *CACHEE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *op = IMMEDIATE(copy(op_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *op = IMMEDIATE(copy(op_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("CACHEE %s, %s(%s)", op, s, rs);
@@ -3494,7 +3496,7 @@ static char *CFC1(uint64 instruction, img_address m_pc)
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *cs = CPR(copy(cs_value));
+    g_autofree char *cs = CPR(copy(cs_value));
 
     return img_format("CFC1 %s, %s", rt, cs);
 }
@@ -3516,7 +3518,7 @@ static char *CFC2(uint64 instruction, img_address m_pc)
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *cs = CPR(copy(cs_value));
+    g_autofree char *cs = CPR(copy(cs_value));
 
     return img_format("CFC2 %s, %s", rt, cs);
 }
@@ -4959,7 +4961,7 @@ static char *COP2_1(uint64 instruction, img_address m_pc)
 {
     uint64 cofun_value = extract_cofun_25_24_23(instruction);
 
-    char *cofun = IMMEDIATE(copy(cofun_value));
+    g_autofree char *cofun = IMMEDIATE(copy(cofun_value));
 
     return img_format("COP2_1 %s", cofun);
 }
@@ -4981,7 +4983,7 @@ static char *CTC1(uint64 instruction, img_address m_pc)
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *cs = CPR(copy(cs_value));
+    g_autofree char *cs = CPR(copy(cs_value));
 
     return img_format("CTC1 %s, %s", rt, cs);
 }
@@ -5003,7 +5005,7 @@ static char *CTC2(uint64 instruction, img_address m_pc)
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *cs = CPR(copy(cs_value));
+    g_autofree char *cs = CPR(copy(cs_value));
 
     return img_format("CTC2 %s, %s", rt, cs);
 }
@@ -5289,7 +5291,7 @@ static char *DADDIU_48_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
 
     return img_format("DADDIU %s, %s", rt, s);
 }
@@ -5313,7 +5315,7 @@ static char *DADDIU_NEG_(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *u = IMMEDIATE(neg_copy(u_value));
+    g_autofree char *u = IMMEDIATE(neg_copy(u_value));
 
     return img_format("DADDIU %s, %s, %s", rt, rs, u);
 }
@@ -5337,7 +5339,7 @@ static char *DADDIU_U12_(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("DADDIU %s, %s, %s", rt, rs, u);
 }
@@ -5497,7 +5499,7 @@ static char *DERET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"DERET ";
+    return strdup("DERET ");
 }
 
 
@@ -5520,8 +5522,8 @@ static char *DEXTM(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *lsb = IMMEDIATE(copy(lsb_value));
-    char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    g_autofree char *lsb = IMMEDIATE(copy(lsb_value));
+    g_autofree char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
     return img_format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -5546,8 +5548,8 @@ static char *DEXT(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *lsb = IMMEDIATE(copy(lsb_value));
-    char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    g_autofree char *lsb = IMMEDIATE(copy(lsb_value));
+    g_autofree char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
     return img_format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -5572,8 +5574,8 @@ static char *DEXTU(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *lsb = IMMEDIATE(copy(lsb_value));
-    char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    g_autofree char *lsb = IMMEDIATE(copy(lsb_value));
+    g_autofree char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
     return img_format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -5598,8 +5600,8 @@ static char *DINSM(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    g_autofree char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
+    g_autofree char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("DINSM %s, %s, %s, %s", rt, rs, pos, size);
@@ -5626,8 +5628,8 @@ static char *DINS(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    g_autofree char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
+    g_autofree char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("DINS %s, %s, %s, %s", rt, rs, pos, size);
@@ -5654,8 +5656,8 @@ static char *DINSU(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    g_autofree char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
+    g_autofree char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("DINSU %s, %s, %s, %s", rt, rs, pos, size);
@@ -5799,7 +5801,7 @@ static char *DLSA(uint64 instruction, img_address m_pc)
     const char *rd = GPR(copy(rd_value));
     const char *rs = GPR(copy(rs_value));
     const char *rt = GPR(copy(rt_value));
-    char *u2 = IMMEDIATE(copy(u2_value));
+    g_autofree char *u2 = IMMEDIATE(copy(u2_value));
 
     return img_format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
 }
@@ -5821,7 +5823,7 @@ static char *DLUI_48_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_31_to_0__s32(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("DLUI %s, %s", rt, u);
 }
@@ -5844,8 +5846,8 @@ static char *DMFC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("DMFC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -5889,7 +5891,7 @@ static char *DMFC2(uint64 instruction, img_address m_pc)
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *cs = CPR(copy(cs_value));
+    g_autofree char *cs = CPR(copy(cs_value));
 
     return img_format("DMFC2 %s, %s", rt, cs);
 }
@@ -5912,8 +5914,8 @@ static char *DMFGC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("DMFGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -5984,8 +5986,8 @@ static char *DMTC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("DMTC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -6029,7 +6031,7 @@ static char *DMTC2(uint64 instruction, img_address m_pc)
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *cs = CPR(copy(cs_value));
+    g_autofree char *cs = CPR(copy(cs_value));
 
     return img_format("DMTC2 %s, %s", rt, cs);
 }
@@ -6052,8 +6054,8 @@ static char *DMTGC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("DMTGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -6578,7 +6580,7 @@ static char *DROTR(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DROTR %s, %s, %s", rt, rs, shift);
 }
@@ -6602,7 +6604,7 @@ static char *DROTR32(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DROTR32 %s, %s, %s", rt, rs, shift);
 }
@@ -6651,8 +6653,8 @@ static char *DROTX(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
-    char *shiftx = IMMEDIATE(copy(shiftx_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shiftx = IMMEDIATE(copy(shiftx_value));
 
     return img_format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
 }
@@ -6676,7 +6678,7 @@ static char *DSLL(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSLL %s, %s, %s", rt, rs, shift);
 }
@@ -6700,7 +6702,7 @@ static char *DSLL32(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSLL32 %s, %s, %s", rt, rs, shift);
 }
@@ -6748,7 +6750,7 @@ static char *DSRA(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSRA %s, %s, %s", rt, rs, shift);
 }
@@ -6772,7 +6774,7 @@ static char *DSRA32(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSRA32 %s, %s, %s", rt, rs, shift);
 }
@@ -6820,7 +6822,7 @@ static char *DSRL(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSRL %s, %s, %s", rt, rs, shift);
 }
@@ -6844,7 +6846,7 @@ static char *DSRL32(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("DSRL32 %s, %s, %s", rt, rs, shift);
 }
@@ -6976,7 +6978,7 @@ static char *EHB(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"EHB ";
+    return strdup("EHB ");
 }
 
 
@@ -7034,7 +7036,7 @@ static char *ERET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"ERET ";
+    return strdup("ERET ");
 }
 
 
@@ -7052,7 +7054,7 @@ static char *ERETNC(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"ERETNC ";
+    return strdup("ERETNC ");
 }
 
 
@@ -7115,8 +7117,8 @@ static char *EXT(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *lsb = IMMEDIATE(copy(lsb_value));
-    char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    g_autofree char *lsb = IMMEDIATE(copy(lsb_value));
+    g_autofree char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
     return img_format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -7142,7 +7144,7 @@ static char *EXTD(uint64 instruction, img_address m_pc)
     const char *rd = GPR(copy(rd_value));
     const char *rs = GPR(copy(rs_value));
     const char *rt = GPR(copy(rt_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
 }
@@ -7168,7 +7170,7 @@ static char *EXTD32(uint64 instruction, img_address m_pc)
     const char *rd = GPR(copy(rd_value));
     const char *rs = GPR(copy(rs_value));
     const char *rt = GPR(copy(rt_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
 }
@@ -7192,7 +7194,7 @@ static char *EXTPDP(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *ac = AC(copy(ac_value));
-    char *size = IMMEDIATE(copy(size_value));
+    g_autofree char *size = IMMEDIATE(copy(size_value));
 
     return img_format("EXTPDP %s, %s, %s", rt, ac, size);
 }
@@ -7240,7 +7242,7 @@ static char *EXTP(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *ac = AC(copy(ac_value));
-    char *size = IMMEDIATE(copy(size_value));
+    g_autofree char *size = IMMEDIATE(copy(size_value));
 
     return img_format("EXTP %s, %s, %s", rt, ac, size);
 }
@@ -7289,7 +7291,7 @@ static char *EXTR_RS_W(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *ac = AC(copy(ac_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
 }
@@ -7314,7 +7316,7 @@ static char *EXTR_R_W(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *ac = AC(copy(ac_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTR_R.W %s, %s, %s", rt, ac, shift);
 }
@@ -7339,7 +7341,7 @@ static char *EXTR_S_H(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *ac = AC(copy(ac_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTR_S.H %s, %s, %s", rt, ac, shift);
 }
@@ -7364,7 +7366,7 @@ static char *EXTR_W(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *ac = AC(copy(ac_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTR.W %s, %s, %s", rt, ac, shift);
 }
@@ -7491,7 +7493,7 @@ static char *EXTW(uint64 instruction, img_address m_pc)
     const char *rd = GPR(copy(rd_value));
     const char *rs = GPR(copy(rs_value));
     const char *rt = GPR(copy(rt_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
 }
@@ -7623,7 +7625,7 @@ static char *HYPCALL(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
-    char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE(copy(code_value));
 
     return img_format("HYPCALL %s", code);
 }
@@ -7643,7 +7645,7 @@ static char *HYPCALL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
-    char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE(copy(code_value));
 
     return img_format("HYPCALL %s", code);
 }
@@ -7668,8 +7670,8 @@ static char *INS(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    g_autofree char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
+    g_autofree char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("INS %s, %s, %s, %s", rt, rs, pos, size);
@@ -7712,7 +7714,7 @@ static char *IRET(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"IRET ";
+    return strdup("IRET ");
 }
 
 
@@ -7817,7 +7819,7 @@ static char *LB_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_1_0(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LB %s, %s(%s)", rt3, u, rs3);
@@ -7840,7 +7842,7 @@ static char *LB_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LB %s, %s($%d)", rt, u, 28);
 }
@@ -7863,7 +7865,7 @@ static char *LB_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LB %s, %s(%s)", rt, s, rs);
@@ -7887,7 +7889,7 @@ static char *LB_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LB %s, %s(%s)", rt, u, rs);
@@ -7911,7 +7913,7 @@ static char *LBE(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LBE %s, %s(%s)", rt, s, rs);
@@ -7935,7 +7937,7 @@ static char *LBU_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_1_0(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LBU %s, %s(%s)", rt3, u, rs3);
@@ -7958,7 +7960,7 @@ static char *LBU_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LBU %s, %s($%d)", rt, u, 28);
 }
@@ -7981,7 +7983,7 @@ static char *LBU_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LBU %s, %s(%s)", rt, s, rs);
@@ -8005,7 +8007,7 @@ static char *LBU_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LBU %s, %s(%s)", rt, u, rs);
@@ -8029,7 +8031,7 @@ static char *LBUE(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LBUE %s, %s(%s)", rt, s, rs);
@@ -8100,7 +8102,7 @@ static char *LD_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_20_to_3__s3(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LD %s, %s($%d)", rt, u, 28);
 }
@@ -8123,7 +8125,7 @@ static char *LD_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LD %s, %s(%s)", rt, s, rs);
@@ -8147,7 +8149,7 @@ static char *LD_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LD %s, %s(%s)", rt, u, rs);
@@ -8170,7 +8172,7 @@ static char *LDC1_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LDC1 %s, %s($%d)", ft, u, 28);
 }
@@ -8193,7 +8195,7 @@ static char *LDC1_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LDC1 %s, %s(%s)", ft, s, rs);
@@ -8217,7 +8219,7 @@ static char *LDC1_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LDC1 %s, %s(%s)", ft, u, rs);
@@ -8288,8 +8290,8 @@ static char *LDC2(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *ct = CPR(copy(ct_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *ct = CPR(copy(ct_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LDC2 %s, %s(%s)", ct, s, rs);
@@ -8314,9 +8316,10 @@ static char *LDM(uint64 instruction, img_address m_pc)
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
-    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(
+        count3_value));
 
     return img_format("LDM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -8338,7 +8341,7 @@ static char *LDPC_48_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("LDPC %s, %s", rt, s);
 }
@@ -8409,7 +8412,7 @@ static char *LH_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_2_1__s1(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LH %s, %s(%s)", rt3, u, rs3);
@@ -8432,7 +8435,7 @@ static char *LH_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LH %s, %s($%d)", rt, u, 28);
 }
@@ -8455,7 +8458,7 @@ static char *LH_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LH %s, %s(%s)", rt, s, rs);
@@ -8479,7 +8482,7 @@ static char *LH_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LH %s, %s(%s)", rt, u, rs);
@@ -8503,7 +8506,7 @@ static char *LHE(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LHE %s, %s(%s)", rt, s, rs);
@@ -8527,7 +8530,7 @@ static char *LHU_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_2_1__s1(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LHU %s, %s(%s)", rt3, u, rs3);
@@ -8550,7 +8553,7 @@ static char *LHU_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LHU %s, %s($%d)", rt, u, 28);
 }
@@ -8573,7 +8576,7 @@ static char *LHU_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LHU %s, %s(%s)", rt, s, rs);
@@ -8597,7 +8600,7 @@ static char *LHU_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LHU %s, %s(%s)", rt, u, rs);
@@ -8621,7 +8624,7 @@ static char *LHUE(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LHUE %s, %s(%s)", rt, s, rs);
@@ -8740,7 +8743,7 @@ static char *LI_16_(uint64 instruction, img_address m_pc)
     uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
+    g_autofree char *eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
 
     return img_format("LI %s, %s", rt3, eu);
 }
@@ -8762,7 +8765,7 @@ static char *LI_48_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
 
     return img_format("LI %s, %s", rt, s);
 }
@@ -8785,7 +8788,7 @@ static char *LL(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LL %s, %s(%s)", rt, s, rs);
@@ -8809,7 +8812,7 @@ static char *LLD(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LLD %s, %s(%s)", rt, s, rs);
@@ -8857,7 +8860,7 @@ static char *LLE(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LLE %s, %s(%s)", rt, s, rs);
@@ -8932,7 +8935,7 @@ static char *LSA(uint64 instruction, img_address m_pc)
     const char *rd = GPR(copy(rd_value));
     const char *rs = GPR(copy(rs_value));
     const char *rt = GPR(copy(rt_value));
-    char *u2 = IMMEDIATE(copy(u2_value));
+    g_autofree char *u2 = IMMEDIATE(copy(u2_value));
 
     return img_format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
 }
@@ -8954,7 +8957,7 @@ static char *LUI(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
 
     return img_format("LUI %s, %%hi(%s)", rt, s);
 }
@@ -8977,7 +8980,7 @@ static char *LW_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_3_2_1_0__s2(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LW %s, %s(%s)", rt3, u, rs3);
@@ -9001,7 +9004,7 @@ static char *LW_4X4_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_3_8__s2(instruction);
 
     const char *rt4 = GPR(decode_gpr_gpr4(rt4_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
 
     return img_format("LW %s, %s(%s)", rt4, u, rs4);
@@ -9024,7 +9027,7 @@ static char *LW_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LW %s, %s($%d)", rt, u, 28);
 }
@@ -9046,7 +9049,7 @@ static char *LW_GP16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LW %s, %s($%d)", rt3, u, 28);
 }
@@ -9069,7 +9072,7 @@ static char *LW_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LW %s, %s(%s)", rt, s, rs);
@@ -9092,7 +9095,7 @@ static char *LW_SP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LW %s, %s($%d)", rt, u, 29);
 }
@@ -9115,7 +9118,7 @@ static char *LW_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LW %s, %s(%s)", rt, u, rs);
@@ -9138,7 +9141,7 @@ static char *LWC1_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LWC1 %s, %s($%d)", ft, u, 28);
 }
@@ -9161,7 +9164,7 @@ static char *LWC1_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LWC1 %s, %s(%s)", ft, s, rs);
@@ -9185,7 +9188,7 @@ static char *LWC1_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LWC1 %s, %s(%s)", ft, u, rs);
@@ -9256,8 +9259,8 @@ static char *LWC2(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *ct = CPR(copy(ct_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *ct = CPR(copy(ct_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LWC2 %s, %s(%s)", ct, s, rs);
@@ -9281,7 +9284,7 @@ static char *LWE(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LWE %s, %s(%s)", rt, s, rs);
@@ -9306,9 +9309,9 @@ static char *LWM(uint64 instruction, img_address m_pc)
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
-    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("LWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -9330,7 +9333,7 @@ static char *LWPC_48_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("LWPC %s, %s", rt, s);
 }
@@ -9352,7 +9355,7 @@ static char *LWU_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("LWU %s, %s($%d)", rt, u, 28);
 }
@@ -9375,7 +9378,7 @@ static char *LWU_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LWU %s, %s(%s)", rt, s, rs);
@@ -9399,7 +9402,7 @@ static char *LWU_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("LWU %s, %s(%s)", rt, u, rs);
@@ -9496,7 +9499,7 @@ static char *LWXS_16_(uint64 instruction, img_address m_pc)
 
     const char *rd3 = GPR(decode_gpr_gpr3(rd3_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    char *rt3 = IMMEDIATE(decode_gpr_gpr3(rt3_value));
+    g_autofree char *rt3 = IMMEDIATE(decode_gpr_gpr3(rt3_value));
 
     return img_format("LWXS %s, %s(%s)", rd3, rs3, rt3);
 }
@@ -9837,8 +9840,8 @@ static char *MFC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -9882,7 +9885,7 @@ static char *MFC2(uint64 instruction, img_address m_pc)
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *cs = CPR(copy(cs_value));
+    g_autofree char *cs = CPR(copy(cs_value));
 
     return img_format("MFC2 %s, %s", rt, cs);
 }
@@ -9905,8 +9908,8 @@ static char *MFGC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -9929,8 +9932,8 @@ static char *MFHC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFHC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -9974,7 +9977,7 @@ static char *MFHC2(uint64 instruction, img_address m_pc)
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *cs = CPR(copy(cs_value));
+    g_autofree char *cs = CPR(copy(cs_value));
 
     return img_format("MFHC2 %s, %s", rt, cs);
 }
@@ -9997,8 +10000,8 @@ static char *MFHGC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFHGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10043,9 +10046,9 @@ static char *MFHTR(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_10(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = IMMEDIATE(copy(c0s_value));
-    char *u = IMMEDIATE(copy(u_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = IMMEDIATE(copy(c0s_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -10090,9 +10093,9 @@ static char *MFTR(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_10(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = IMMEDIATE(copy(c0s_value));
-    char *u = IMMEDIATE(copy(u_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = IMMEDIATE(copy(c0s_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -10328,7 +10331,7 @@ static char *MOVE_BALC(uint64 instruction, img_address m_pc)
 
     const char *rd1 = GPR(decode_gpr_gpr1(rd1_value));
     const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
 }
@@ -10571,8 +10574,8 @@ static char *MTC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10616,7 +10619,7 @@ static char *MTC2(uint64 instruction, img_address m_pc)
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *cs = CPR(copy(cs_value));
+    g_autofree char *cs = CPR(copy(cs_value));
 
     return img_format("MTC2 %s, %s", rt, cs);
 }
@@ -10639,8 +10642,8 @@ static char *MTGC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10663,8 +10666,8 @@ static char *MTHC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTHC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10708,7 +10711,7 @@ static char *MTHC2(uint64 instruction, img_address m_pc)
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *cs = CPR(copy(cs_value));
+    g_autofree char *cs = CPR(copy(cs_value));
 
     return img_format("MTHC2 %s, %s", rt, cs);
 }
@@ -10731,8 +10734,8 @@ static char *MTHGC0(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = CPR(copy(c0s_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = CPR(copy(c0s_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTHGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10798,9 +10801,9 @@ static char *MTHTR(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_10(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = IMMEDIATE(copy(c0s_value));
-    char *u = IMMEDIATE(copy(u_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = IMMEDIATE(copy(c0s_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -10845,9 +10848,9 @@ static char *MTTR(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_10(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *c0s = IMMEDIATE(copy(c0s_value));
-    char *u = IMMEDIATE(copy(u_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *c0s = IMMEDIATE(copy(c0s_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -11425,7 +11428,7 @@ static char *NOP_16_(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"NOP ";
+    return strdup("NOP ");
 }
 
 
@@ -11443,7 +11446,7 @@ static char *NOP_32_(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"NOP ";
+    return strdup("NOP ");
 }
 
 
@@ -11557,7 +11560,7 @@ static char *ORI(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("ORI %s, %s, %s", rt, rs, u);
 }
@@ -11602,7 +11605,7 @@ static char *PAUSE(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"PAUSE ";
+    return strdup("PAUSE ");
 }
 
 
@@ -11932,7 +11935,7 @@ static char *PRECR_SRA_PH_W(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
 }
@@ -11957,7 +11960,7 @@ static char *PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
 }
@@ -12079,8 +12082,8 @@ static char *PREF_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *hint = IMMEDIATE(copy(hint_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *hint = IMMEDIATE(copy(hint_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("PREF %s, %s(%s)", hint, s, rs);
@@ -12103,8 +12106,8 @@ static char *PREF_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    char *hint = IMMEDIATE(copy(hint_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *hint = IMMEDIATE(copy(hint_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("PREF %s, %s(%s)", hint, u, rs);
@@ -12127,8 +12130,8 @@ static char *PREFE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *hint = IMMEDIATE(copy(hint_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *hint = IMMEDIATE(copy(hint_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("PREFE %s, %s(%s)", hint, s, rs);
@@ -12153,7 +12156,7 @@ static char *PREPEND(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("PREPEND %s, %s, %s", rt, rs, sa);
 }
@@ -12195,7 +12198,7 @@ static char *RDDSP(uint64 instruction, img_address m_pc)
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *mask = IMMEDIATE(copy(mask_value));
+    g_autofree char *mask = IMMEDIATE(copy(mask_value));
 
     return img_format("RDDSP %s, %s", rt, mask);
 }
@@ -12218,8 +12221,8 @@ static char *RDHWR(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *hs = CPR(copy(hs_value));
-    char *sel = IMMEDIATE(copy(sel_value));
+    g_autofree char *hs = CPR(copy(hs_value));
+    g_autofree char *sel = IMMEDIATE(copy(sel_value));
 
     return img_format("RDHWR %s, %s, %s", rt, hs, sel);
 }
@@ -12307,7 +12310,7 @@ static char *REPL_PH(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se9_20_19_18_17_16_15_14_13_12_11(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
 
     return img_format("REPL.PH %s, %s", rt, s);
 }
@@ -12329,7 +12332,7 @@ static char *REPL_QB(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("REPL.QB %s, %s", rt, u);
 }
@@ -12395,9 +12398,10 @@ static char *RESTORE_32_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
     uint64 gp_value = extract_gp_2(instruction);
 
-    char *u = IMMEDIATE(copy(u_value));
-    return img_format("RESTORE %s%s", u,
-               save_restore_list(rt_value, count_value, gp_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *save_restore_str = save_restore_list(
+        rt_value, count_value, gp_value);
+    return img_format("RESTORE %s%s", u, save_restore_str);
 }
 
 
@@ -12417,9 +12421,10 @@ static char *RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
     uint64 count_value = extract_count_3_2_1_0(instruction);
 
-    char *u = IMMEDIATE(copy(u_value));
-    return img_format("RESTORE.JRC %s%s", u,
-        save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *save_restore_str = save_restore_list(
+        encode_rt1_from_rt(rt1_value), count_value, 0);
+    return img_format("RESTORE.JRC %s%s", u, save_restore_str);
 }
 
 
@@ -12440,9 +12445,10 @@ static char *RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
     uint64 gp_value = extract_gp_2(instruction);
 
-    char *u = IMMEDIATE(copy(u_value));
-    return img_format("RESTORE.JRC %s%s", u,
-               save_restore_list(rt_value, count_value, gp_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *save_restore_str = save_restore_list(
+        rt_value, count_value, gp_value);
+    return img_format("RESTORE.JRC %s%s", u, save_restore_str);
 }
 
 
@@ -12461,8 +12467,8 @@ static char *RESTOREF(uint64 instruction, img_address m_pc)
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
 
-    char *u = IMMEDIATE(copy(u_value));
-    char *count = IMMEDIATE(copy(count_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *count = IMMEDIATE(copy(count_value));
 
     return img_format("RESTOREF %s, %s", u, count);
 }
@@ -12530,7 +12536,7 @@ static char *ROTR(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("ROTR %s, %s, %s", rt, rs, shift);
 }
@@ -12580,9 +12586,9 @@ static char *ROTX(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
-    char *shiftx = IMMEDIATE(copy(shiftx_value));
-    char *stripe = IMMEDIATE(copy(stripe_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shiftx = IMMEDIATE(copy(shiftx_value));
+    g_autofree char *stripe = IMMEDIATE(copy(stripe_value));
 
     return img_format("ROTX %s, %s, %s, %s, %s",
                        rt, rs, shift, shiftx, stripe);
@@ -12737,9 +12743,10 @@ static char *SAVE_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
     uint64 count_value = extract_count_3_2_1_0(instruction);
 
-    char *u = IMMEDIATE(copy(u_value));
-    return img_format("SAVE %s%s", u,
-        save_restore_list(encode_rt1_from_rt(rt1_value), count_value, 0));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *save_restore_str = save_restore_list(
+        encode_rt1_from_rt(rt1_value), count_value, 0);
+    return img_format("SAVE %s%s", u, save_restore_str);
 }
 
 
@@ -12760,9 +12767,10 @@ static char *SAVE_32_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
     uint64 gp_value = extract_gp_2(instruction);
 
-    char *u = IMMEDIATE(copy(u_value));
-    return img_format("SAVE %s%s", u,
-               save_restore_list(rt_value, count_value, gp_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *save_restore_str = save_restore_list(
+        rt_value, count_value, gp_value);
+    return img_format("SAVE %s%s", u, save_restore_str);
 }
 
 
@@ -12781,8 +12789,8 @@ static char *SAVEF(uint64 instruction, img_address m_pc)
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
 
-    char *u = IMMEDIATE(copy(u_value));
-    char *count = IMMEDIATE(copy(count_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *count = IMMEDIATE(copy(count_value));
 
     return img_format("SAVEF %s, %s", u, count);
 }
@@ -12805,7 +12813,7 @@ static char *SB_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_1_0(instruction);
 
     const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("SB %s, %s(%s)", rtz3, u, rs3);
@@ -12828,7 +12836,7 @@ static char *SB_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SB %s, %s($%d)", rt, u, 28);
 }
@@ -12851,7 +12859,7 @@ static char *SB_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SB %s, %s(%s)", rt, s, rs);
@@ -12875,7 +12883,7 @@ static char *SB_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SB %s, %s(%s)", rt, u, rs);
@@ -12899,7 +12907,7 @@ static char *SBE(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SBE %s, %s(%s)", rt, s, rs);
@@ -12947,7 +12955,7 @@ static char *SC(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SC %s, %s(%s)", rt, s, rs);
@@ -12971,7 +12979,7 @@ static char *SCD(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SCD %s, %s(%s)", rt, s, rs);
@@ -13019,7 +13027,7 @@ static char *SCE(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SCE %s, %s(%s)", rt, s, rs);
@@ -13090,7 +13098,7 @@ static char *SD_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_20_to_3__s3(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SD %s, %s($%d)", rt, u, 28);
 }
@@ -13113,7 +13121,7 @@ static char *SD_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SD %s, %s(%s)", rt, s, rs);
@@ -13137,7 +13145,7 @@ static char *SD_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SD %s, %s(%s)", rt, u, rs);
@@ -13158,7 +13166,7 @@ static char *SDBBP_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
-    char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE(copy(code_value));
 
     return img_format("SDBBP %s", code);
 }
@@ -13178,7 +13186,7 @@ static char *SDBBP_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
-    char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE(copy(code_value));
 
     return img_format("SDBBP %s", code);
 }
@@ -13200,7 +13208,7 @@ static char *SDC1_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SDC1 %s, %s($%d)", ft, u, 28);
 }
@@ -13223,7 +13231,7 @@ static char *SDC1_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SDC1 %s, %s(%s)", ft, s, rs);
@@ -13247,7 +13255,7 @@ static char *SDC1_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SDC1 %s, %s(%s)", ft, u, rs);
@@ -13318,8 +13326,8 @@ static char *SDC2(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *cs = CPR(copy(cs_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *cs = CPR(copy(cs_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SDC2 %s, %s(%s)", cs, s, rs);
@@ -13344,9 +13352,9 @@ static char *SDM(uint64 instruction, img_address m_pc)
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
-    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("SDM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -13368,7 +13376,7 @@ static char *SDPC_48_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("SDPC %s, %s", rt, s);
 }
@@ -13628,7 +13636,7 @@ static char *SEQI(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SEQI %s, %s, %s", rt, rs, u);
 }
@@ -13651,7 +13659,7 @@ static char *SH_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_2_1__s1(instruction);
 
     const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("SH %s, %s(%s)", rtz3, u, rs3);
@@ -13674,7 +13682,7 @@ static char *SH_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SH %s, %s($%d)", rt, u, 28);
 }
@@ -13697,7 +13705,7 @@ static char *SH_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SH %s, %s(%s)", rt, s, rs);
@@ -13721,7 +13729,7 @@ static char *SH_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SH %s, %s(%s)", rt, u, rs);
@@ -13745,7 +13753,7 @@ static char *SHE(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SHE %s, %s(%s)", rt, s, rs);
@@ -13767,7 +13775,7 @@ static char *SHILO(uint64 instruction, img_address m_pc)
     int64 shift_value = extract_shift__se5_21_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
     const char *ac = AC(copy(ac_value));
 
     return img_format("SHILO %s, %s", ac, shift);
@@ -13814,7 +13822,7 @@ static char *SHLL_PH(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHLL.PH %s, %s, %s", rt, rs, sa);
 }
@@ -13838,7 +13846,7 @@ static char *SHLL_QB(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHLL.QB %s, %s, %s", rt, rs, sa);
 }
@@ -13863,7 +13871,7 @@ static char *SHLL_S_PH(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
 }
@@ -13887,7 +13895,7 @@ static char *SHLL_S_W(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHLL_S.W %s, %s, %s", rt, rs, sa);
 }
@@ -14009,7 +14017,7 @@ static char *SHRA_PH(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRA.PH %s, %s, %s", rt, rs, sa);
 }
@@ -14033,7 +14041,7 @@ static char *SHRA_QB(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRA.QB %s, %s, %s", rt, rs, sa);
 }
@@ -14057,7 +14065,7 @@ static char *SHRA_R_PH(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
 }
@@ -14081,7 +14089,7 @@ static char *SHRA_R_QB(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
 }
@@ -14105,7 +14113,7 @@ static char *SHRA_R_W(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRA_R.W %s, %s, %s", rt, rs, sa);
 }
@@ -14249,7 +14257,7 @@ static char *SHRL_PH(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRL.PH %s, %s, %s", rt, rs, sa);
 }
@@ -14273,7 +14281,7 @@ static char *SHRL_QB(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *sa = IMMEDIATE(copy(sa_value));
+    g_autofree char *sa = IMMEDIATE(copy(sa_value));
 
     return img_format("SHRL.QB %s, %s, %s", rt, rs, sa);
 }
@@ -14390,7 +14398,7 @@ static char *SIGRIE(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
-    char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE(copy(code_value));
 
     return img_format("SIGRIE %s", code);
 }
@@ -14414,7 +14422,7 @@ static char *SLL_16_(uint64 instruction, img_address m_pc)
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    char *shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
+    g_autofree char *shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
 
     return img_format("SLL %s, %s, %s", rt3, rs3, shift3);
 }
@@ -14438,7 +14446,7 @@ static char *SLL_32_(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("SLL %s, %s, %s", rt, rs, shift);
 }
@@ -14510,7 +14518,7 @@ static char *SLTI(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SLTI %s, %s, %s", rt, rs, u);
 }
@@ -14534,7 +14542,7 @@ static char *SLTIU(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SLTIU %s, %s, %s", rt, rs, u);
 }
@@ -14602,7 +14610,7 @@ static char *SPECIAL2(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
-    char *op = IMMEDIATE(copy(op_value));
+    g_autofree char *op = IMMEDIATE(copy(op_value));
 
     return img_format("SPECIAL2 %s", op);
 }
@@ -14670,7 +14678,7 @@ static char *SRA(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("SRA %s, %s, %s", rt, rs, shift);
 }
@@ -14718,7 +14726,7 @@ static char *SRL_16_(uint64 instruction, img_address m_pc)
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    char *shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
+    g_autofree char *shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
 
     return img_format("SRL %s, %s, %s", rt3, rs3, shift3);
 }
@@ -14742,7 +14750,7 @@ static char *SRL_32_(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *shift = IMMEDIATE(copy(shift_value));
+    g_autofree char *shift = IMMEDIATE(copy(shift_value));
 
     return img_format("SRL %s, %s, %s", rt, rs, shift);
 }
@@ -15231,7 +15239,7 @@ static char *SW_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_3_2_1_0__s2(instruction);
 
     const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("SW %s, %s(%s)", rtz3, u, rs3);
@@ -15255,7 +15263,7 @@ static char *SW_4X4_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_3_8__s2(instruction);
 
     const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
 
     return img_format("SW %s, %s(%s)", rtz4, u, rs4);
@@ -15278,7 +15286,7 @@ static char *SW_GP16_(uint64 instruction, img_address m_pc)
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
 
     const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SW %s, %s($%d)", rtz3, u, 28);
 }
@@ -15300,7 +15308,7 @@ static char *SW_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SW %s, %s($%d)", rt, u, 28);
 }
@@ -15323,7 +15331,7 @@ static char *SW_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SW %s, %s(%s)", rt, s, rs);
@@ -15346,7 +15354,7 @@ static char *SW_SP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SW %s, %s($%d)", rt, u, 29);
 }
@@ -15369,7 +15377,7 @@ static char *SW_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SW %s, %s(%s)", rt, u, rs);
@@ -15392,7 +15400,7 @@ static char *SWC1_GP_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("SWC1 %s, %s($%d)", ft, u, 28);
 }
@@ -15415,7 +15423,7 @@ static char *SWC1_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SWC1 %s, %s(%s)", ft, s, rs);
@@ -15439,7 +15447,7 @@ static char *SWC1_U12_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
     const char *ft = FPR(copy(ft_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SWC1 %s, %s(%s)", ft, u, rs);
@@ -15510,8 +15518,8 @@ static char *SWC2(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *cs = CPR(copy(cs_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *cs = CPR(copy(cs_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SWC2 %s, %s(%s)", cs, s, rs);
@@ -15535,7 +15543,7 @@ static char *SWE(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SWE %s, %s(%s)", rt, s, rs);
@@ -15560,9 +15568,9 @@ static char *SWM(uint64 instruction, img_address m_pc)
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
-    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("SWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -15584,7 +15592,7 @@ static char *SWPC_48_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("SWPC %s, %s", rt, s);
 }
@@ -15652,7 +15660,7 @@ static char *SYNC(uint64 instruction, img_address m_pc)
 {
     uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
 
-    char *stype = IMMEDIATE(copy(stype_value));
+    g_autofree char *stype = IMMEDIATE(copy(stype_value));
 
     return img_format("SYNC %s", stype);
 }
@@ -15673,7 +15681,7 @@ static char *SYNCI(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SYNCI %s(%s)", s, rs);
@@ -15695,7 +15703,7 @@ static char *SYNCIE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("SYNCIE %s(%s)", s, rs);
@@ -15716,7 +15724,7 @@ static char *SYSCALL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
-    char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE(copy(code_value));
 
     return img_format("SYSCALL %s", code);
 }
@@ -15734,7 +15742,7 @@ static char *SYSCALL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
-    char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE(copy(code_value));
 
     return img_format("SYSCALL %s", code);
 }
@@ -15776,7 +15784,7 @@ static char *TLBGINV(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBGINV ";
+    return strdup("TLBGINV ");
 }
 
 
@@ -15794,7 +15802,7 @@ static char *TLBGINVF(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBGINVF ";
+    return strdup("TLBGINVF ");
 }
 
 
@@ -15812,7 +15820,7 @@ static char *TLBGP(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBGP ";
+    return strdup("TLBGP ");
 }
 
 
@@ -15830,7 +15838,7 @@ static char *TLBGR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBGR ";
+    return strdup("TLBGR ");
 }
 
 
@@ -15848,7 +15856,7 @@ static char *TLBGWI(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBGWI ";
+    return strdup("TLBGWI ");
 }
 
 
@@ -15866,7 +15874,7 @@ static char *TLBGWR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBGWR ";
+    return strdup("TLBGWR ");
 }
 
 
@@ -15884,7 +15892,7 @@ static char *TLBINV(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBINV ";
+    return strdup("TLBINV ");
 }
 
 
@@ -15902,7 +15910,7 @@ static char *TLBINVF(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBINVF ";
+    return strdup("TLBINVF ");
 }
 
 
@@ -15920,7 +15928,7 @@ static char *TLBP(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBP ";
+    return strdup("TLBP ");
 }
 
 
@@ -15938,7 +15946,7 @@ static char *TLBR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBR ";
+    return strdup("TLBR ");
 }
 
 
@@ -15956,7 +15964,7 @@ static char *TLBWI(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBWI ";
+    return strdup("TLBWI ");
 }
 
 
@@ -15974,7 +15982,7 @@ static char *TLBWR(uint64 instruction, img_address m_pc)
 {
     (void)instruction;
 
-    return (char *)"TLBWR ";
+    return strdup("TLBWR ");
 }
 
 
@@ -16106,9 +16114,9 @@ static char *UALDM(uint64 instruction, img_address m_pc)
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
-    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16131,7 +16139,7 @@ static char *UALH(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("UALH %s, %s(%s)", rt, s, rs);
@@ -16156,9 +16164,9 @@ static char *UALWM(uint64 instruction, img_address m_pc)
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
-    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16182,9 +16190,9 @@ static char *UASDM(uint64 instruction, img_address m_pc)
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
-    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16207,7 +16215,7 @@ static char *UASH(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
     return img_format("UASH %s, %s(%s)", rt, s, rs);
@@ -16232,9 +16240,9 @@ static char *UASWM(uint64 instruction, img_address m_pc)
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *s = IMMEDIATE(copy(s_value));
+    g_autofree char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
-    char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
     return img_format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16254,7 +16262,7 @@ static char *UDI(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
-    char *op = IMMEDIATE(copy(op_value));
+    g_autofree char *op = IMMEDIATE(copy(op_value));
 
     return img_format("UDI %s", op);
 }
@@ -16272,7 +16280,7 @@ static char *WAIT(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
 
-    char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE(copy(code_value));
 
     return img_format("WAIT %s", code);
 }
@@ -16294,7 +16302,7 @@ static char *WRDSP(uint64 instruction, img_address m_pc)
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
 
     const char *rt = GPR(copy(rt_value));
-    char *mask = IMMEDIATE(copy(mask_value));
+    g_autofree char *mask = IMMEDIATE(copy(mask_value));
 
     return img_format("WRDSP %s, %s", rt, mask);
 }
@@ -16386,7 +16394,7 @@ static char *XORI(uint64 instruction, img_address m_pc)
 
     const char *rt = GPR(copy(rt_value));
     const char *rs = GPR(copy(rs_value));
-    char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE(copy(u_value));
 
     return img_format("XORI %s, %s, %s", rt, rs, u);
 }
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 13/20] disas/nanomips: Prevent memory leaking
  2022-09-05  9:55 ` [PATCH v2 13/20] disas/nanomips: Prevent memory leaking Milica Lazarevic
@ 2022-09-05 11:41   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:41 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> g_autofree attribute is added for every dynamically allocated string to
> prevent memory leaking.
> 
> The implementation of the several functions that work with dynamically
> allocated strings is slightly changed so we can add those attributes.
> 
> Almost every disassembly_function returns the result of the img_format()
> function, which returns a dynamically allocated string. To be able to
> free that string for every disassembly_function, a strdup() call is
> added for a return value of some disassembly functions like TLBGINV,
> TLBGINVF, TLBGP, etc.
> 
> Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
> ---
>   disas/nanomips.cpp | 714 +++++++++++++++++++++++----------------------
>   1 file changed, 361 insertions(+), 353 deletions(-)
> 
> diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
> index cfea95130d..473c202649 100644
> --- a/disas/nanomips.cpp
> +++ b/disas/nanomips.cpp
> @@ -523,7 +523,8 @@ static char *save_restore_list(uint64 rt, uint64 count, uint64 gp)
>       for (uint64 counter = 0; counter != count; counter++) {
>           bool use_gp = gp && (counter == count - 1);
>           uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
> -        strcat(str, img_format(",%s", GPR(this_rt)));
> +        g_autofree char *dis_str = img_format(",%s", GPR(this_rt));
> +        strcat(str, dis_str);
>       }

Will be unnecessary with the g_strjoinv change I suggested.


> @@ -657,7 +658,8 @@ static int Disassemble(const uint16 *data, char *dis,
>                                   return -6;
>                               }
>                               type = table[i].type;
> -                            strcpy(dis, dis_fn(op_code, m_pc));
> +                            g_autofree char *dis_str = dis_fn(op_code, m_pc);
> +                            strcpy(dis, dis_str);
>                               return table[i].instructions_size;

Will be unnecessary with the "*dis = value" return I suggested.

> @@ -1727,8 +1729,8 @@ static char *ACLR(uint64 instruction, img_address m_pc)
>       uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
>       int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
>   
> -    char *bit = IMMEDIATE(copy(bit_value));
> -    char *s = IMMEDIATE(copy(s_value));
> +    g_autofree char *bit = IMMEDIATE(copy(bit_value));
> +    g_autofree char *s = IMMEDIATE(copy(s_value));
>       const char *rs = GPR(copy(rs_value));
>   
>       return img_format("ACLR %s, %s(%s)", bit, s, rs);

All of these should be switched to directly use printf format on the integer values, now 
that's supported by img_format.  That should be done as a separate patch, immediately 
before this one.


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 14/20] disas/nanomips: Remove function overloading
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (12 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 13/20] disas/nanomips: Prevent memory leaking Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:43   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 15/20] disas/nanomips: Introduce Dis_info struct Milica Lazarevic
                   ` (5 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

Renamed the following functions by adding a suffix:
- copy to copy_ui and copy_i
- IMMEDIATE to IMMEDIATE_UI and IMMEDIATE_I
Calls to copy and IMMEDIATE functions are replaced based on the type of
arguments.

Disassemble function that calls the other variant of it is deleted.
Where it is called, now we're directly calling the other implementation.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Acked-by: Thomas Huth <thuth@redhat.com>
---
 disas/nanomips.cpp | 3118 ++++++++++++++++++++++----------------------
 1 file changed, 1565 insertions(+), 1553 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index 473c202649..9e34ca164c 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -391,13 +391,13 @@ static uint64 decode_gpr_gpr1(uint64 d)
 }
 
 
-static uint64 copy(uint64 d)
+static uint64 copy_ui(uint64 d)
 {
     return d;
 }
 
 
-static int64 copy(int64 d)
+static int64 copy_i(int64 d)
 {
     return d;
 }
@@ -564,13 +564,13 @@ static const char *AC(uint64 reg)
 }
 
 
-static char *IMMEDIATE(uint64 value)
+static char *IMMEDIATE_UI(uint64 value)
 {
     return img_format("0x%" PRIx64, value);
 }
 
 
-static char *IMMEDIATE(int64 value)
+static char *IMMEDIATE_I(int64 value)
 {
     return img_format("%" PRId64, value);
 }
@@ -1619,8 +1619,8 @@ static char *ABS_D(uint64 instruction, img_address m_pc)
     uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *fs = FPR(copy(fs_value));
-    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *fd = FPR(copy_ui(fd_value));
 
     return img_format("ABS.D %s, %s", fd, fs);
 }
@@ -1641,8 +1641,8 @@ static char *ABS_S(uint64 instruction, img_address m_pc)
     uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *fs = FPR(copy(fs_value));
-    const char *fd = FPR(copy(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *fd = FPR(copy_ui(fd_value));
 
     return img_format("ABS.S %s, %s", fd, fs);
 }
@@ -1663,8 +1663,8 @@ static char *ABSQ_S_PH(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("ABSQ_S.PH %s, %s", rt, rs);
 }
@@ -1685,8 +1685,8 @@ static char *ABSQ_S_QB(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("ABSQ_S.QB %s, %s", rt, rs);
 }
@@ -1707,8 +1707,8 @@ static char *ABSQ_S_W(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("ABSQ_S.W %s, %s", rt, rs);
 }
@@ -1729,9 +1729,9 @@ static char *ACLR(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *bit = IMMEDIATE(copy(bit_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *bit = IMMEDIATE_UI(copy_ui(bit_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("ACLR %s, %s(%s)", bit, s, rs);
 }
@@ -1752,9 +1752,9 @@ static char *ADD(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADD %s, %s, %s", rd, rs, rt);
 }
@@ -1777,9 +1777,9 @@ static char *ADD_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *fd = FPR(copy(fd_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *fd = FPR(copy_ui(fd_value));
 
     return img_format("ADD.D %s, %s, %s", fd, fs, ft);
 }
@@ -1802,9 +1802,9 @@ static char *ADD_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *fd = FPR(copy(fd_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *fd = FPR(copy_ui(fd_value));
 
     return img_format("ADD.S %s, %s, %s", fd, fs, ft);
 }
@@ -1825,9 +1825,9 @@ static char *ADDIU_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_15_to_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt, rs, u);
 }
@@ -1847,8 +1847,8 @@ static char *ADDIU_48_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("ADDIU %s, %s", rt, s);
 }
@@ -1868,8 +1868,8 @@ static char *ADDIU_GP48_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, s);
 }
@@ -1889,8 +1889,8 @@ static char *ADDIU_GP_B_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, u);
 }
@@ -1910,8 +1910,8 @@ static char *ADDIU_GP_W_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, u);
 }
@@ -1932,9 +1932,9 @@ static char *ADDIU_NEG_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *u = IMMEDIATE(neg_copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *u = IMMEDIATE_I(neg_copy(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt, rs, u);
 }
@@ -1955,7 +1955,7 @@ static char *ADDIU_R1_SP_(uint64 instruction, img_address m_pc)
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt3, 29, u);
 }
@@ -1978,7 +1978,7 @@ static char *ADDIU_R2_(uint64 instruction, img_address m_pc)
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt3, rs3, u);
 }
@@ -1997,8 +1997,8 @@ static char *ADDIU_RS5_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     int64 s_value = extract_s__se3_4_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("ADDIU %s, %s", rt, s);
 }
@@ -2019,7 +2019,7 @@ static char *ADDIUPC_32_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("ADDIUPC %s, %s", rt, s);
@@ -2041,7 +2041,7 @@ static char *ADDIUPC_48_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("ADDIUPC %s, %s", rt, s);
@@ -2064,9 +2064,9 @@ static char *ADDQ_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDQ.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2089,9 +2089,9 @@ static char *ADDQ_S_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2113,9 +2113,9 @@ static char *ADDQ_S_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
 }
@@ -2138,9 +2138,9 @@ static char *ADDQH_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDQH.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2163,9 +2163,9 @@ static char *ADDQH_R_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2188,9 +2188,9 @@ static char *ADDQH_R_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
 }
@@ -2213,9 +2213,9 @@ static char *ADDQH_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDQH.W %s, %s, %s", rd, rs, rt);
 }
@@ -2237,9 +2237,9 @@ static char *ADDSC(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDSC %s, %s, %s", rd, rs, rt);
 }
@@ -2284,9 +2284,9 @@ static char *ADDU_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDU %s, %s, %s", rd, rs, rt);
 }
@@ -2330,9 +2330,9 @@ static char *ADDU_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDU.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2354,9 +2354,9 @@ static char *ADDU_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDU.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2379,9 +2379,9 @@ static char *ADDU_S_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2403,9 +2403,9 @@ static char *ADDU_S_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2428,9 +2428,9 @@ static char *ADDUH_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDUH.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2453,9 +2453,9 @@ static char *ADDUH_R_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2476,9 +2476,9 @@ static char *ADDWC(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ADDWC %s, %s, %s", rd, rs, rt);
 }
@@ -2499,7 +2499,7 @@ static char *ALUIPC(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
@@ -2543,9 +2543,9 @@ static char *AND_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("AND %s, %s, %s", rd, rs, rt);
 }
@@ -2568,7 +2568,7 @@ static char *ANDI_16_(uint64 instruction, img_address m_pc)
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    g_autofree char *eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
+    g_autofree char *eu = IMMEDIATE_UI(encode_eu_from_u_andi16(eu_value));
 
     return img_format("ANDI %s, %s, %s", rt3, rs3, eu);
 }
@@ -2590,9 +2590,9 @@ static char *ANDI_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ANDI %s, %s, %s", rt, rs, u);
 }
@@ -2614,9 +2614,9 @@ static char *APPEND(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("APPEND %s, %s, %s", rt, rs, sa);
 }
@@ -2638,9 +2638,9 @@ static char *ASET(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *bit = IMMEDIATE(copy(bit_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *bit = IMMEDIATE_UI(copy_ui(bit_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("ASET %s, %s(%s)", bit, s, rs);
 }
@@ -2701,8 +2701,8 @@ static char *BALRSC(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("BALRSC %s, %s", rt, rs);
 }
@@ -2724,8 +2724,8 @@ static char *BBEQZC(uint64 instruction, img_address m_pc)
     uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *bit = IMMEDIATE(copy(bit_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *bit = IMMEDIATE_UI(copy_ui(bit_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BBEQZC %s, %s, %s", rt, bit, s);
@@ -2748,8 +2748,8 @@ static char *BBNEZC(uint64 instruction, img_address m_pc)
     uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *bit = IMMEDIATE(copy(bit_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *bit = IMMEDIATE_UI(copy_ui(bit_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BBNEZC %s, %s, %s", rt, bit, s);
@@ -2811,7 +2811,7 @@ static char *BC1EQZC(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *ft = FPR(copy(ft_value));
+    const char *ft = FPR(copy_ui(ft_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC1EQZC %s, %s", ft, s);
@@ -2833,7 +2833,7 @@ static char *BC1NEZC(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *ft = FPR(copy(ft_value));
+    const char *ft = FPR(copy_ui(ft_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC1NEZC %s, %s", ft, s);
@@ -2855,7 +2855,7 @@ static char *BC2EQZC(uint64 instruction, img_address m_pc)
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    g_autofree char *ct = CPR(copy(ct_value));
+    g_autofree char *ct = CPR(copy_ui(ct_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC2EQZC %s, %s", ct, s);
@@ -2877,7 +2877,7 @@ static char *BC2NEZC(uint64 instruction, img_address m_pc)
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    g_autofree char *ct = CPR(copy(ct_value));
+    g_autofree char *ct = CPR(copy_ui(ct_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BC2NEZC %s, %s", ct, s);
@@ -2924,8 +2924,8 @@ static char *BEQC_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BEQC %s, %s, %s", rs, rt, s);
@@ -2948,8 +2948,8 @@ static char *BEQIC(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BEQIC %s, %s, %s", rt, u, s);
@@ -2994,8 +2994,8 @@ static char *BGEC(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEC %s, %s, %s", rs, rt, s);
@@ -3018,8 +3018,8 @@ static char *BGEIC(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEIC %s, %s, %s", rt, u, s);
@@ -3042,8 +3042,8 @@ static char *BGEIUC(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEIUC %s, %s, %s", rt, u, s);
@@ -3066,8 +3066,8 @@ static char *BGEUC(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BGEUC %s, %s, %s", rs, rt, s);
@@ -3090,8 +3090,8 @@ static char *BLTC(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTC %s, %s, %s", rs, rt, s);
@@ -3114,8 +3114,8 @@ static char *BLTIC(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTIC %s, %s, %s", rt, u, s);
@@ -3138,8 +3138,8 @@ static char *BLTIUC(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTIUC %s, %s, %s", rt, u, s);
@@ -3162,8 +3162,8 @@ static char *BLTUC(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BLTUC %s, %s, %s", rs, rt, s);
@@ -3210,8 +3210,8 @@ static char *BNEC_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BNEC %s, %s, %s", rs, rt, s);
@@ -3234,8 +3234,8 @@ static char *BNEIC(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
 
     return img_format("BNEIC %s, %s, %s", rt, u, s);
@@ -3298,7 +3298,7 @@ static char *BREAK_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
-    g_autofree char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE_UI(copy_ui(code_value));
 
     return img_format("BREAK %s", code);
 }
@@ -3318,7 +3318,7 @@ static char *BREAK_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
-    g_autofree char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE_UI(copy_ui(code_value));
 
     return img_format("BREAK %s", code);
 }
@@ -3338,7 +3338,7 @@ static char *BRSC(uint64 instruction, img_address m_pc)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy(rs_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("BRSC %s", rs);
 }
@@ -3360,9 +3360,9 @@ static char *CACHE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *op = IMMEDIATE(copy(op_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *op = IMMEDIATE_UI(copy_ui(op_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("CACHE %s, %s(%s)", op, s, rs);
 }
@@ -3384,9 +3384,9 @@ static char *CACHEE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *op = IMMEDIATE(copy(op_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *op = IMMEDIATE_UI(copy_ui(op_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("CACHEE %s, %s(%s)", op, s, rs);
 }
@@ -3407,8 +3407,8 @@ static char *CEIL_L_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CEIL.L.D %s, %s", ft, fs);
 }
@@ -3429,8 +3429,8 @@ static char *CEIL_L_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CEIL.L.S %s, %s", ft, fs);
 }
@@ -3451,8 +3451,8 @@ static char *CEIL_W_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CEIL.W.D %s, %s", ft, fs);
 }
@@ -3473,8 +3473,8 @@ static char *CEIL_W_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CEIL.W.S %s, %s", ft, fs);
 }
@@ -3495,8 +3495,8 @@ static char *CFC1(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("CFC1 %s, %s", rt, cs);
 }
@@ -3517,8 +3517,8 @@ static char *CFC2(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("CFC2 %s, %s", rt, cs);
 }
@@ -3539,8 +3539,8 @@ static char *CLASS_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CLASS.D %s, %s", ft, fs);
 }
@@ -3561,8 +3561,8 @@ static char *CLASS_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CLASS.S %s, %s", ft, fs);
 }
@@ -3583,8 +3583,8 @@ static char *CLO(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("CLO %s, %s", rt, rs);
 }
@@ -3605,8 +3605,8 @@ static char *CLZ(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("CLZ %s, %s", rt, rs);
 }
@@ -3628,9 +3628,9 @@ static char *CMP_AF_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.AF.D %s, %s, %s", fd, fs, ft);
 }
@@ -3652,9 +3652,9 @@ static char *CMP_AF_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.AF.S %s, %s, %s", fd, fs, ft);
 }
@@ -3676,9 +3676,9 @@ static char *CMP_EQ_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -3698,8 +3698,8 @@ static char *CMP_EQ_PH(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMP.EQ.PH %s, %s", rs, rt);
 }
@@ -3721,9 +3721,9 @@ static char *CMP_EQ_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -3745,9 +3745,9 @@ static char *CMP_LE_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.LE.D %s, %s, %s", fd, fs, ft);
 }
@@ -3767,8 +3767,8 @@ static char *CMP_LE_PH(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMP.LE.PH %s, %s", rs, rt);
 }
@@ -3790,9 +3790,9 @@ static char *CMP_LE_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.LE.S %s, %s, %s", fd, fs, ft);
 }
@@ -3814,9 +3814,9 @@ static char *CMP_LT_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.LT.D %s, %s, %s", fd, fs, ft);
 }
@@ -3836,8 +3836,8 @@ static char *CMP_LT_PH(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMP.LT.PH %s, %s", rs, rt);
 }
@@ -3859,9 +3859,9 @@ static char *CMP_LT_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.LT.S %s, %s, %s", fd, fs, ft);
 }
@@ -3883,9 +3883,9 @@ static char *CMP_NE_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.NE.D %s, %s, %s", fd, fs, ft);
 }
@@ -3907,9 +3907,9 @@ static char *CMP_NE_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.NE.S %s, %s, %s", fd, fs, ft);
 }
@@ -3931,9 +3931,9 @@ static char *CMP_OR_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.OR.D %s, %s, %s", fd, fs, ft);
 }
@@ -3955,9 +3955,9 @@ static char *CMP_OR_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.OR.S %s, %s, %s", fd, fs, ft);
 }
@@ -3979,9 +3979,9 @@ static char *CMP_SAF_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
 }
@@ -4003,9 +4003,9 @@ static char *CMP_SAF_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
 }
@@ -4027,9 +4027,9 @@ static char *CMP_SEQ_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -4051,9 +4051,9 @@ static char *CMP_SEQ_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -4075,9 +4075,9 @@ static char *CMP_SLE_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4099,9 +4099,9 @@ static char *CMP_SLE_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4123,9 +4123,9 @@ static char *CMP_SLT_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
 }
@@ -4147,9 +4147,9 @@ static char *CMP_SLT_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
 }
@@ -4171,9 +4171,9 @@ static char *CMP_SNE_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4195,9 +4195,9 @@ static char *CMP_SNE_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4219,9 +4219,9 @@ static char *CMP_SOR_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
 }
@@ -4243,9 +4243,9 @@ static char *CMP_SOR_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
 }
@@ -4267,9 +4267,9 @@ static char *CMP_SUEQ_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -4291,9 +4291,9 @@ static char *CMP_SUEQ_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -4315,9 +4315,9 @@ static char *CMP_SULE_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4339,9 +4339,9 @@ static char *CMP_SULE_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4363,9 +4363,9 @@ static char *CMP_SULT_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
 }
@@ -4387,9 +4387,9 @@ static char *CMP_SULT_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
 }
@@ -4411,9 +4411,9 @@ static char *CMP_SUN_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
 }
@@ -4435,9 +4435,9 @@ static char *CMP_SUNE_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4459,9 +4459,9 @@ static char *CMP_SUNE_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4483,9 +4483,9 @@ static char *CMP_SUN_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
 }
@@ -4507,9 +4507,9 @@ static char *CMP_UEQ_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -4531,9 +4531,9 @@ static char *CMP_UEQ_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -4555,9 +4555,9 @@ static char *CMP_ULE_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4579,9 +4579,9 @@ static char *CMP_ULE_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4603,9 +4603,9 @@ static char *CMP_ULT_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
 }
@@ -4627,9 +4627,9 @@ static char *CMP_ULT_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
 }
@@ -4651,9 +4651,9 @@ static char *CMP_UN_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.UN.D %s, %s, %s", fd, fs, ft);
 }
@@ -4675,9 +4675,9 @@ static char *CMP_UNE_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4699,9 +4699,9 @@ static char *CMP_UNE_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4723,9 +4723,9 @@ static char *CMP_UN_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("CMP.UN.S %s, %s, %s", fd, fs, ft);
 }
@@ -4748,9 +4748,9 @@ static char *CMPGDU_EQ_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4773,9 +4773,9 @@ static char *CMPGDU_LE_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4798,9 +4798,9 @@ static char *CMPGDU_LT_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4823,9 +4823,9 @@ static char *CMPGU_EQ_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4848,9 +4848,9 @@ static char *CMPGU_LE_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4873,9 +4873,9 @@ static char *CMPGU_LT_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4896,8 +4896,8 @@ static char *CMPU_EQ_QB(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMPU.EQ.QB %s, %s", rs, rt);
 }
@@ -4918,8 +4918,8 @@ static char *CMPU_LE_QB(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMPU.LE.QB %s, %s", rs, rt);
 }
@@ -4940,8 +4940,8 @@ static char *CMPU_LT_QB(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("CMPU.LT.QB %s, %s", rs, rt);
 }
@@ -4961,7 +4961,7 @@ static char *COP2_1(uint64 instruction, img_address m_pc)
 {
     uint64 cofun_value = extract_cofun_25_24_23(instruction);
 
-    g_autofree char *cofun = IMMEDIATE(copy(cofun_value));
+    g_autofree char *cofun = IMMEDIATE_UI(copy_ui(cofun_value));
 
     return img_format("COP2_1 %s", cofun);
 }
@@ -4982,8 +4982,8 @@ static char *CTC1(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("CTC1 %s, %s", rt, cs);
 }
@@ -5004,8 +5004,8 @@ static char *CTC2(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("CTC2 %s, %s", rt, cs);
 }
@@ -5026,8 +5026,8 @@ static char *CVT_D_L(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.D.L %s, %s", ft, fs);
 }
@@ -5048,8 +5048,8 @@ static char *CVT_D_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.D.S %s, %s", ft, fs);
 }
@@ -5070,8 +5070,8 @@ static char *CVT_D_W(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.D.W %s, %s", ft, fs);
 }
@@ -5092,8 +5092,8 @@ static char *CVT_L_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.L.D %s, %s", ft, fs);
 }
@@ -5114,8 +5114,8 @@ static char *CVT_L_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.L.S %s, %s", ft, fs);
 }
@@ -5136,8 +5136,8 @@ static char *CVT_S_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.S.D %s, %s", ft, fs);
 }
@@ -5158,8 +5158,8 @@ static char *CVT_S_L(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.S.L %s, %s", ft, fs);
 }
@@ -5180,8 +5180,8 @@ static char *CVT_S_PL(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.S.PL %s, %s", ft, fs);
 }
@@ -5202,8 +5202,8 @@ static char *CVT_S_PU(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.S.PU %s, %s", ft, fs);
 }
@@ -5224,8 +5224,8 @@ static char *CVT_S_W(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.S.W %s, %s", ft, fs);
 }
@@ -5246,8 +5246,8 @@ static char *CVT_W_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.W.D %s, %s", ft, fs);
 }
@@ -5268,8 +5268,8 @@ static char *CVT_W_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("CVT.W.S %s, %s", ft, fs);
 }
@@ -5290,8 +5290,8 @@ static char *DADDIU_48_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("DADDIU %s, %s", rt, s);
 }
@@ -5313,9 +5313,9 @@ static char *DADDIU_NEG_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *u = IMMEDIATE(neg_copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *u = IMMEDIATE_I(neg_copy(u_value));
 
     return img_format("DADDIU %s, %s, %s", rt, rs, u);
 }
@@ -5337,9 +5337,9 @@ static char *DADDIU_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("DADDIU %s, %s, %s", rt, rs, u);
 }
@@ -5361,9 +5361,9 @@ static char *DADD(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DADD %s, %s, %s", rd, rs, rt);
 }
@@ -5385,9 +5385,9 @@ static char *DADDU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DADDU %s, %s, %s", rd, rs, rt);
 }
@@ -5408,8 +5408,8 @@ static char *DCLO(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("DCLO %s, %s", rt, rs);
 }
@@ -5430,8 +5430,8 @@ static char *DCLZ(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("DCLZ %s, %s", rt, rs);
 }
@@ -5453,9 +5453,9 @@ static char *DDIV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DDIV %s, %s, %s", rd, rs, rt);
 }
@@ -5477,9 +5477,9 @@ static char *DDIVU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DDIVU %s, %s, %s", rd, rs, rt);
 }
@@ -5520,10 +5520,10 @@ static char *DEXTM(uint64 instruction, img_address m_pc)
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *lsb = IMMEDIATE(copy(lsb_value));
-    g_autofree char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *lsb = IMMEDIATE_UI(copy_ui(lsb_value));
+    g_autofree char *msbd = IMMEDIATE_UI(encode_msbd_from_size(msbd_value));
 
     return img_format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -5546,10 +5546,10 @@ static char *DEXT(uint64 instruction, img_address m_pc)
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *lsb = IMMEDIATE(copy(lsb_value));
-    g_autofree char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *lsb = IMMEDIATE_UI(copy_ui(lsb_value));
+    g_autofree char *msbd = IMMEDIATE_UI(encode_msbd_from_size(msbd_value));
 
     return img_format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -5572,10 +5572,10 @@ static char *DEXTU(uint64 instruction, img_address m_pc)
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *lsb = IMMEDIATE(copy(lsb_value));
-    g_autofree char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *lsb = IMMEDIATE_UI(copy_ui(lsb_value));
+    g_autofree char *msbd = IMMEDIATE_UI(encode_msbd_from_size(msbd_value));
 
     return img_format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -5598,10 +5598,12 @@ static char *DINSM(uint64 instruction, img_address m_pc)
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    g_autofree char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *pos = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
+        lsb_value));
+    g_autofree char *size = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
+        msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("DINSM %s, %s, %s, %s", rt, rs, pos, size);
@@ -5626,10 +5628,12 @@ static char *DINS(uint64 instruction, img_address m_pc)
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    g_autofree char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *pos = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
+        lsb_value));
+    g_autofree char *size = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
+        msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("DINS %s, %s, %s, %s", rt, rs, pos, size);
@@ -5654,10 +5658,12 @@ static char *DINSU(uint64 instruction, img_address m_pc)
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    g_autofree char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *pos = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
+        lsb_value));
+    g_autofree char *size = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
+        msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("DINSU %s, %s, %s, %s", rt, rs, pos, size);
@@ -5679,7 +5685,7 @@ static char *DI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DI %s", rt);
 }
@@ -5701,9 +5707,9 @@ static char *DIV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DIV %s, %s, %s", rd, rs, rt);
 }
@@ -5725,9 +5731,9 @@ static char *DIV_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("DIV.D %s, %s, %s", fd, fs, ft);
 }
@@ -5749,9 +5755,9 @@ static char *DIV_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("DIV.S %s, %s, %s", fd, fs, ft);
 }
@@ -5773,9 +5779,9 @@ static char *DIVU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DIVU %s, %s, %s", rd, rs, rt);
 }
@@ -5798,10 +5804,10 @@ static char *DLSA(uint64 instruction, img_address m_pc)
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 u2_value = extract_u2_10_9(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u2 = IMMEDIATE(copy(u2_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u2 = IMMEDIATE_UI(copy_ui(u2_value));
 
     return img_format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
 }
@@ -5822,8 +5828,8 @@ static char *DLUI_48_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     uint64 u_value = extract_u_31_to_0__s32(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("DLUI %s, %s", rt, u);
 }
@@ -5845,9 +5851,9 @@ static char *DMFC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("DMFC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -5868,8 +5874,8 @@ static char *DMFC1(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("DMFC1 %s, %s", rt, fs);
 }
@@ -5890,8 +5896,8 @@ static char *DMFC2(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("DMFC2 %s, %s", rt, cs);
 }
@@ -5913,9 +5919,9 @@ static char *DMFGC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("DMFGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -5937,9 +5943,9 @@ static char *DMOD(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DMOD %s, %s, %s", rd, rs, rt);
 }
@@ -5961,9 +5967,9 @@ static char *DMODU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DMODU %s, %s, %s", rd, rs, rt);
 }
@@ -5985,9 +5991,9 @@ static char *DMTC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("DMTC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -6008,8 +6014,8 @@ static char *DMTC1(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("DMTC1 %s, %s", rt, fs);
 }
@@ -6030,8 +6036,8 @@ static char *DMTC2(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("DMTC2 %s, %s", rt, cs);
 }
@@ -6053,9 +6059,9 @@ static char *DMTGC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("DMTGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -6075,7 +6081,7 @@ static char *DMT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DMT %s", rt);
 }
@@ -6097,9 +6103,9 @@ static char *DMUH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DMUH %s, %s, %s", rd, rs, rt);
 }
@@ -6121,9 +6127,9 @@ static char *DMUHU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DMUHU %s, %s, %s", rd, rs, rt);
 }
@@ -6145,9 +6151,9 @@ static char *DMUL(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DMUL %s, %s, %s", rd, rs, rt);
 }
@@ -6169,9 +6175,9 @@ static char *DMULU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DMULU %s, %s, %s", rd, rs, rt);
 }
@@ -6194,9 +6200,9 @@ static char *DPA_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6218,9 +6224,9 @@ static char *DPAQ_SA_L_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPAQ_SA.L.W %s, %s, %s", ac, rs, rt);
 }
@@ -6242,9 +6248,9 @@ static char *DPAQ_S_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPAQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6266,9 +6272,9 @@ static char *DPAQX_SA_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6290,9 +6296,9 @@ static char *DPAQX_S_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6314,9 +6320,9 @@ static char *DPAU_H_QBL(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
 }
@@ -6338,9 +6344,9 @@ static char *DPAU_H_QBR(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
 }
@@ -6362,9 +6368,9 @@ static char *DPAX_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6386,9 +6392,9 @@ static char *DPS_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPS.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6410,9 +6416,9 @@ static char *DPSQ_SA_L_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
 }
@@ -6434,9 +6440,9 @@ static char *DPSQ_S_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6458,9 +6464,9 @@ static char *DPSQX_SA_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6482,9 +6488,9 @@ static char *DPSQX_S_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6506,9 +6512,9 @@ static char *DPSU_H_QBL(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
 }
@@ -6530,9 +6536,9 @@ static char *DPSU_H_QBR(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
 }
@@ -6554,9 +6560,9 @@ static char *DPSX_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6578,9 +6584,9 @@ static char *DROTR(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DROTR %s, %s, %s", rt, rs, shift);
 }
@@ -6602,9 +6608,9 @@ static char *DROTR32(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DROTR32 %s, %s, %s", rt, rs, shift);
 }
@@ -6626,9 +6632,9 @@ static char *DROTRV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DROTRV %s, %s, %s", rd, rs, rt);
 }
@@ -6651,10 +6657,10 @@ static char *DROTX(uint64 instruction, img_address m_pc)
     uint64 shiftx_value = extract_shiftx_11_10_9_8_7_6(instruction);
     uint64 shift_value = extract_shift_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
-    g_autofree char *shiftx = IMMEDIATE(copy(shiftx_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
+    g_autofree char *shiftx = IMMEDIATE_UI(copy_ui(shiftx_value));
 
     return img_format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
 }
@@ -6676,9 +6682,9 @@ static char *DSLL(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSLL %s, %s, %s", rt, rs, shift);
 }
@@ -6700,9 +6706,9 @@ static char *DSLL32(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSLL32 %s, %s, %s", rt, rs, shift);
 }
@@ -6724,9 +6730,9 @@ static char *DSLLV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DSLLV %s, %s, %s", rd, rs, rt);
 }
@@ -6748,9 +6754,9 @@ static char *DSRA(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSRA %s, %s, %s", rt, rs, shift);
 }
@@ -6772,9 +6778,9 @@ static char *DSRA32(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSRA32 %s, %s, %s", rt, rs, shift);
 }
@@ -6796,9 +6802,9 @@ static char *DSRAV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DSRAV %s, %s, %s", rd, rs, rt);
 }
@@ -6820,9 +6826,9 @@ static char *DSRL(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSRL %s, %s, %s", rt, rs, shift);
 }
@@ -6844,9 +6850,9 @@ static char *DSRL32(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSRL32 %s, %s, %s", rt, rs, shift);
 }
@@ -6868,9 +6874,9 @@ static char *DSRLV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DSRLV %s, %s, %s", rd, rs, rt);
 }
@@ -6892,9 +6898,9 @@ static char *DSUB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DSUB %s, %s, %s", rd, rs, rt);
 }
@@ -6916,9 +6922,9 @@ static char *DSUBU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DSUBU %s, %s, %s", rd, rs, rt);
 }
@@ -6938,7 +6944,7 @@ static char *DVPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DVPE %s", rt);
 }
@@ -6958,7 +6964,7 @@ static char *DVP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("DVP %s", rt);
 }
@@ -6996,7 +7002,7 @@ static char *EI(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("EI %s", rt);
 }
@@ -7016,7 +7022,7 @@ static char *EMT(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("EMT %s", rt);
 }
@@ -7072,7 +7078,7 @@ static char *EVP(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("EVP %s", rt);
 }
@@ -7092,7 +7098,7 @@ static char *EVPE(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("EVPE %s", rt);
 }
@@ -7115,10 +7121,10 @@ static char *EXT(uint64 instruction, img_address m_pc)
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *lsb = IMMEDIATE(copy(lsb_value));
-    g_autofree char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *lsb = IMMEDIATE_UI(copy_ui(lsb_value));
+    g_autofree char *msbd = IMMEDIATE_UI(encode_msbd_from_size(msbd_value));
 
     return img_format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
 }
@@ -7141,10 +7147,10 @@ static char *EXTD(uint64 instruction, img_address m_pc)
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
 }
@@ -7167,10 +7173,10 @@ static char *EXTD32(uint64 instruction, img_address m_pc)
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
 }
@@ -7192,9 +7198,9 @@ static char *EXTPDP(uint64 instruction, img_address m_pc)
     uint64 size_value = extract_size_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    g_autofree char *size = IMMEDIATE(copy(size_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    g_autofree char *size = IMMEDIATE_UI(copy_ui(size_value));
 
     return img_format("EXTPDP %s, %s, %s", rt, ac, size);
 }
@@ -7216,9 +7222,9 @@ static char *EXTPDPV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("EXTPDPV %s, %s, %s", rt, ac, rs);
 }
@@ -7240,9 +7246,9 @@ static char *EXTP(uint64 instruction, img_address m_pc)
     uint64 size_value = extract_size_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    g_autofree char *size = IMMEDIATE(copy(size_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    g_autofree char *size = IMMEDIATE_UI(copy_ui(size_value));
 
     return img_format("EXTP %s, %s, %s", rt, ac, size);
 }
@@ -7264,9 +7270,9 @@ static char *EXTPV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("EXTPV %s, %s, %s", rt, ac, rs);
 }
@@ -7289,9 +7295,9 @@ static char *EXTR_RS_W(uint64 instruction, img_address m_pc)
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
 }
@@ -7314,9 +7320,9 @@ static char *EXTR_R_W(uint64 instruction, img_address m_pc)
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTR_R.W %s, %s, %s", rt, ac, shift);
 }
@@ -7339,9 +7345,9 @@ static char *EXTR_S_H(uint64 instruction, img_address m_pc)
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTR_S.H %s, %s, %s", rt, ac, shift);
 }
@@ -7364,9 +7370,9 @@ static char *EXTR_W(uint64 instruction, img_address m_pc)
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTR.W %s, %s, %s", rt, ac, shift);
 }
@@ -7389,9 +7395,9 @@ static char *EXTRV_RS_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
 }
@@ -7414,9 +7420,9 @@ static char *EXTRV_R_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
 }
@@ -7439,9 +7445,9 @@ static char *EXTRV_S_H(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
 }
@@ -7464,9 +7470,9 @@ static char *EXTRV_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("EXTRV.W %s, %s, %s", rt, ac, rs);
 }
@@ -7490,10 +7496,10 @@ static char *EXTW(uint64 instruction, img_address m_pc)
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
 }
@@ -7514,8 +7520,8 @@ static char *FLOOR_L_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("FLOOR.L.D %s, %s", ft, fs);
 }
@@ -7536,8 +7542,8 @@ static char *FLOOR_L_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("FLOOR.L.S %s, %s", ft, fs);
 }
@@ -7558,8 +7564,8 @@ static char *FLOOR_W_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("FLOOR.W.D %s, %s", ft, fs);
 }
@@ -7580,8 +7586,8 @@ static char *FLOOR_W_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("FLOOR.W.S %s, %s", ft, fs);
 }
@@ -7603,9 +7609,9 @@ static char *FORK(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("FORK %s, %s, %s", rd, rs, rt);
 }
@@ -7625,7 +7631,7 @@ static char *HYPCALL(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
-    g_autofree char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE_UI(copy_ui(code_value));
 
     return img_format("HYPCALL %s", code);
 }
@@ -7645,7 +7651,7 @@ static char *HYPCALL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
-    g_autofree char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE_UI(copy_ui(code_value));
 
     return img_format("HYPCALL %s", code);
 }
@@ -7668,10 +7674,12 @@ static char *INS(uint64 instruction, img_address m_pc)
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *pos = IMMEDIATE(encode_lsb_from_pos_and_size(lsb_value));
-    g_autofree char *size = IMMEDIATE(encode_lsb_from_pos_and_size(msbd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *pos = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
+        lsb_value));
+    g_autofree char *size = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
+        msbd_value));
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("INS %s, %s, %s, %s", rt, rs, pos, size);
@@ -7693,8 +7701,8 @@ static char *INSV(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("INSV %s, %s", rt, rs);
 }
@@ -7732,7 +7740,7 @@ static char *JALRC_16_(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("JALRC $%d, %s", 31, rt);
 }
@@ -7753,8 +7761,8 @@ static char *JALRC_32_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("JALRC %s, %s", rt, rs);
 }
@@ -7775,8 +7783,8 @@ static char *JALRC_HB(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("JALRC.HB %s, %s", rt, rs);
 }
@@ -7796,7 +7804,7 @@ static char *JRC(uint64 instruction, img_address m_pc)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("JRC %s", rt);
 }
@@ -7819,7 +7827,7 @@ static char *LB_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_1_0(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LB %s, %s(%s)", rt3, u, rs3);
@@ -7841,8 +7849,8 @@ static char *LB_GP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LB %s, %s($%d)", rt, u, 28);
 }
@@ -7864,9 +7872,9 @@ static char *LB_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LB %s, %s(%s)", rt, s, rs);
 }
@@ -7888,9 +7896,9 @@ static char *LB_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LB %s, %s(%s)", rt, u, rs);
 }
@@ -7912,9 +7920,9 @@ static char *LBE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LBE %s, %s(%s)", rt, s, rs);
 }
@@ -7937,7 +7945,7 @@ static char *LBU_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_1_0(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LBU %s, %s(%s)", rt3, u, rs3);
@@ -7959,8 +7967,8 @@ static char *LBU_GP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LBU %s, %s($%d)", rt, u, 28);
 }
@@ -7982,9 +7990,9 @@ static char *LBU_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LBU %s, %s(%s)", rt, s, rs);
 }
@@ -8006,9 +8014,9 @@ static char *LBU_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LBU %s, %s(%s)", rt, u, rs);
 }
@@ -8030,9 +8038,9 @@ static char *LBUE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LBUE %s, %s(%s)", rt, s, rs);
 }
@@ -8054,9 +8062,9 @@ static char *LBUX(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LBUX %s, %s(%s)", rd, rs, rt);
 }
@@ -8078,9 +8086,9 @@ static char *LBX(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LBX %s, %s(%s)", rd, rs, rt);
 }
@@ -8101,8 +8109,8 @@ static char *LD_GP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_3__s3(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LD %s, %s($%d)", rt, u, 28);
 }
@@ -8124,9 +8132,9 @@ static char *LD_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LD %s, %s(%s)", rt, s, rs);
 }
@@ -8148,9 +8156,9 @@ static char *LD_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LD %s, %s(%s)", rt, u, rs);
 }
@@ -8171,8 +8179,8 @@ static char *LDC1_GP_(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LDC1 %s, %s($%d)", ft, u, 28);
 }
@@ -8194,9 +8202,9 @@ static char *LDC1_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LDC1 %s, %s(%s)", ft, s, rs);
 }
@@ -8218,9 +8226,9 @@ static char *LDC1_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LDC1 %s, %s(%s)", ft, u, rs);
 }
@@ -8242,9 +8250,9 @@ static char *LDC1XS(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LDC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -8266,9 +8274,9 @@ static char *LDC1X(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LDC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -8290,9 +8298,9 @@ static char *LDC2(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *ct = CPR(copy(ct_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *ct = CPR(copy_ui(ct_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LDC2 %s, %s(%s)", ct, s, rs);
 }
@@ -8315,10 +8323,10 @@ static char *LDM(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
         count3_value));
 
     return img_format("LDM %s, %s(%s), %s", rt, s, rs, count3);
@@ -8340,7 +8348,7 @@ static char *LDPC_48_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("LDPC %s, %s", rt, s);
@@ -8363,9 +8371,9 @@ static char *LDX(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LDX %s, %s(%s)", rd, rs, rt);
 }
@@ -8387,9 +8395,9 @@ static char *LDXS(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LDXS %s, %s(%s)", rd, rs, rt);
 }
@@ -8412,7 +8420,7 @@ static char *LH_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_2_1__s1(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LH %s, %s(%s)", rt3, u, rs3);
@@ -8434,8 +8442,8 @@ static char *LH_GP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LH %s, %s($%d)", rt, u, 28);
 }
@@ -8457,9 +8465,9 @@ static char *LH_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LH %s, %s(%s)", rt, s, rs);
 }
@@ -8481,9 +8489,9 @@ static char *LH_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LH %s, %s(%s)", rt, u, rs);
 }
@@ -8505,9 +8513,9 @@ static char *LHE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LHE %s, %s(%s)", rt, s, rs);
 }
@@ -8530,7 +8538,7 @@ static char *LHU_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_2_1__s1(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LHU %s, %s(%s)", rt3, u, rs3);
@@ -8552,8 +8560,8 @@ static char *LHU_GP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LHU %s, %s($%d)", rt, u, 28);
 }
@@ -8575,9 +8583,9 @@ static char *LHU_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LHU %s, %s(%s)", rt, s, rs);
 }
@@ -8599,9 +8607,9 @@ static char *LHU_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LHU %s, %s(%s)", rt, u, rs);
 }
@@ -8623,9 +8631,9 @@ static char *LHUE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LHUE %s, %s(%s)", rt, s, rs);
 }
@@ -8647,9 +8655,9 @@ static char *LHUX(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LHUX %s, %s(%s)", rd, rs, rt);
 }
@@ -8671,9 +8679,9 @@ static char *LHUXS(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LHUXS %s, %s(%s)", rd, rs, rt);
 }
@@ -8695,9 +8703,9 @@ static char *LHXS(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LHXS %s, %s(%s)", rd, rs, rt);
 }
@@ -8719,9 +8727,9 @@ static char *LHX(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LHX %s, %s(%s)", rd, rs, rt);
 }
@@ -8743,7 +8751,7 @@ static char *LI_16_(uint64 instruction, img_address m_pc)
     uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
+    g_autofree char *eu = IMMEDIATE_I(encode_eu_from_s_li16(eu_value));
 
     return img_format("LI %s, %s", rt3, eu);
 }
@@ -8764,8 +8772,8 @@ static char *LI_48_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("LI %s, %s", rt, s);
 }
@@ -8787,9 +8795,9 @@ static char *LL(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LL %s, %s(%s)", rt, s, rs);
 }
@@ -8811,9 +8819,9 @@ static char *LLD(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LLD %s, %s(%s)", rt, s, rs);
 }
@@ -8835,9 +8843,9 @@ static char *LLDP(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ru = GPR(copy(ru_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ru = GPR(copy_ui(ru_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LLDP %s, %s, (%s)", rt, ru, rs);
 }
@@ -8859,9 +8867,9 @@ static char *LLE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LLE %s, %s(%s)", rt, s, rs);
 }
@@ -8883,9 +8891,9 @@ static char *LLWP(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ru = GPR(copy(ru_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ru = GPR(copy_ui(ru_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LLWP %s, %s, (%s)", rt, ru, rs);
 }
@@ -8907,9 +8915,9 @@ static char *LLWPE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ru = GPR(copy(ru_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ru = GPR(copy_ui(ru_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LLWPE %s, %s, (%s)", rt, ru, rs);
 }
@@ -8932,10 +8940,10 @@ static char *LSA(uint64 instruction, img_address m_pc)
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 u2_value = extract_u2_10_9(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u2 = IMMEDIATE(copy(u2_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u2 = IMMEDIATE_UI(copy_ui(u2_value));
 
     return img_format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
 }
@@ -8956,8 +8964,8 @@ static char *LUI(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("LUI %s, %%hi(%s)", rt, s);
 }
@@ -8980,7 +8988,7 @@ static char *LW_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_3_2_1_0__s2(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("LW %s, %s(%s)", rt3, u, rs3);
@@ -9004,7 +9012,7 @@ static char *LW_4X4_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_3_8__s2(instruction);
 
     const char *rt4 = GPR(decode_gpr_gpr4(rt4_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
 
     return img_format("LW %s, %s(%s)", rt4, u, rs4);
@@ -9026,8 +9034,8 @@ static char *LW_GP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LW %s, %s($%d)", rt, u, 28);
 }
@@ -9049,7 +9057,7 @@ static char *LW_GP16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LW %s, %s($%d)", rt3, u, 28);
 }
@@ -9071,9 +9079,9 @@ static char *LW_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LW %s, %s(%s)", rt, s, rs);
 }
@@ -9094,8 +9102,8 @@ static char *LW_SP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LW %s, %s($%d)", rt, u, 29);
 }
@@ -9117,9 +9125,9 @@ static char *LW_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LW %s, %s(%s)", rt, u, rs);
 }
@@ -9140,8 +9148,8 @@ static char *LWC1_GP_(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LWC1 %s, %s($%d)", ft, u, 28);
 }
@@ -9163,9 +9171,9 @@ static char *LWC1_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LWC1 %s, %s(%s)", ft, s, rs);
 }
@@ -9187,9 +9195,9 @@ static char *LWC1_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LWC1 %s, %s(%s)", ft, u, rs);
 }
@@ -9211,9 +9219,9 @@ static char *LWC1X(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LWC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -9235,9 +9243,9 @@ static char *LWC1XS(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LWC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -9259,9 +9267,9 @@ static char *LWC2(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *ct = CPR(copy(ct_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *ct = CPR(copy_ui(ct_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LWC2 %s, %s(%s)", ct, s, rs);
 }
@@ -9283,9 +9291,9 @@ static char *LWE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LWE %s, %s(%s)", rt, s, rs);
 }
@@ -9308,10 +9316,11 @@ static char *LWM(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
+        count3_value));
 
     return img_format("LWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -9332,7 +9341,7 @@ static char *LWPC_48_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("LWPC %s, %s", rt, s);
@@ -9354,8 +9363,8 @@ static char *LWU_GP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LWU %s, %s($%d)", rt, u, 28);
 }
@@ -9377,9 +9386,9 @@ static char *LWU_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LWU %s, %s(%s)", rt, s, rs);
 }
@@ -9401,9 +9410,9 @@ static char *LWU_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("LWU %s, %s(%s)", rt, u, rs);
 }
@@ -9425,9 +9434,9 @@ static char *LWUX(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LWUX %s, %s(%s)", rd, rs, rt);
 }
@@ -9449,9 +9458,9 @@ static char *LWUXS(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LWUXS %s, %s(%s)", rd, rs, rt);
 }
@@ -9473,9 +9482,9 @@ static char *LWX(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LWX %s, %s(%s)", rd, rs, rt);
 }
@@ -9499,7 +9508,7 @@ static char *LWXS_16_(uint64 instruction, img_address m_pc)
 
     const char *rd3 = GPR(decode_gpr_gpr3(rd3_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    g_autofree char *rt3 = IMMEDIATE(decode_gpr_gpr3(rt3_value));
+    g_autofree char *rt3 = IMMEDIATE_UI(decode_gpr_gpr3(rt3_value));
 
     return img_format("LWXS %s, %s(%s)", rd3, rs3, rt3);
 }
@@ -9521,9 +9530,9 @@ static char *LWXS_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("LWXS %s, %s(%s)", rd, rs, rt);
 }
@@ -9546,9 +9555,9 @@ static char *MADD_DSP_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MADD %s, %s, %s", ac, rs, rt);
 }
@@ -9570,9 +9579,9 @@ static char *MADDF_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MADDF.D %s, %s, %s", fd, fs, ft);
 }
@@ -9594,9 +9603,9 @@ static char *MADDF_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MADDF.S %s, %s, %s", fd, fs, ft);
 }
@@ -9619,9 +9628,9 @@ static char *MADDU_DSP_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MADDU %s, %s, %s", ac, rs, rt);
 }
@@ -9644,9 +9653,9 @@ static char *MAQ_S_W_PHL(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
 }
@@ -9669,9 +9678,9 @@ static char *MAQ_S_W_PHR(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
 }
@@ -9694,9 +9703,9 @@ static char *MAQ_SA_W_PHL(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
 }
@@ -9719,9 +9728,9 @@ static char *MAQ_SA_W_PHR(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
 }
@@ -9743,9 +9752,9 @@ static char *MAX_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MAX.D %s, %s, %s", fd, fs, ft);
 }
@@ -9767,9 +9776,9 @@ static char *MAX_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MAX.S %s, %s, %s", fd, fs, ft);
 }
@@ -9791,9 +9800,9 @@ static char *MAXA_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MAXA.D %s, %s, %s", fd, fs, ft);
 }
@@ -9815,9 +9824,9 @@ static char *MAXA_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MAXA.S %s, %s, %s", fd, fs, ft);
 }
@@ -9839,9 +9848,9 @@ static char *MFC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MFC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -9862,8 +9871,8 @@ static char *MFC1(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("MFC1 %s, %s", rt, fs);
 }
@@ -9884,8 +9893,8 @@ static char *MFC2(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("MFC2 %s, %s", rt, cs);
 }
@@ -9907,9 +9916,9 @@ static char *MFGC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MFGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -9931,9 +9940,9 @@ static char *MFHC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MFHC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -9954,8 +9963,8 @@ static char *MFHC1(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("MFHC1 %s, %s", rt, fs);
 }
@@ -9976,8 +9985,8 @@ static char *MFHC2(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("MFHC2 %s, %s", rt, cs);
 }
@@ -9999,9 +10008,9 @@ static char *MFHGC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MFHGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10021,8 +10030,8 @@ static char *MFHI_DSP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
 
     return img_format("MFHI %s, %s", rt, ac);
 }
@@ -10045,10 +10054,10 @@ static char *MFHTR(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = IMMEDIATE(copy(c0s_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = IMMEDIATE_UI(copy_ui(c0s_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -10068,8 +10077,8 @@ static char *MFLO_DSP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ac = AC(copy(ac_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
 
     return img_format("MFLO %s, %s", rt, ac);
 }
@@ -10092,10 +10101,10 @@ static char *MFTR(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = IMMEDIATE(copy(c0s_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = IMMEDIATE_UI(copy_ui(c0s_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -10117,9 +10126,9 @@ static char *MIN_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MIN.D %s, %s, %s", fd, fs, ft);
 }
@@ -10141,9 +10150,9 @@ static char *MIN_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MIN.S %s, %s, %s", fd, fs, ft);
 }
@@ -10165,9 +10174,9 @@ static char *MINA_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MINA.D %s, %s, %s", fd, fs, ft);
 }
@@ -10189,9 +10198,9 @@ static char *MINA_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MINA.S %s, %s, %s", fd, fs, ft);
 }
@@ -10213,9 +10222,9 @@ static char *MOD(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MOD %s, %s, %s", rd, rs, rt);
 }
@@ -10237,9 +10246,9 @@ static char *MODSUB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MODSUB %s, %s, %s", rd, rs, rt);
 }
@@ -10261,9 +10270,9 @@ static char *MODU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MODU %s, %s, %s", rd, rs, rt);
 }
@@ -10284,8 +10293,8 @@ static char *MOV_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("MOV.D %s, %s", ft, fs);
 }
@@ -10306,8 +10315,8 @@ static char *MOV_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("MOV.S %s, %s", ft, fs);
 }
@@ -10406,8 +10415,8 @@ static char *MOVE(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("MOVE %s, %s", rt, rs);
 }
@@ -10429,9 +10438,9 @@ static char *MOVN(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MOVN %s, %s, %s", rd, rs, rt);
 }
@@ -10453,9 +10462,9 @@ static char *MOVZ(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MOVZ %s, %s, %s", rd, rs, rt);
 }
@@ -10477,9 +10486,9 @@ static char *MSUB_DSP_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MSUB %s, %s, %s", ac, rs, rt);
 }
@@ -10501,9 +10510,9 @@ static char *MSUBF_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MSUBF.D %s, %s, %s", fd, fs, ft);
 }
@@ -10525,9 +10534,9 @@ static char *MSUBF_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MSUBF.S %s, %s, %s", fd, fs, ft);
 }
@@ -10549,9 +10558,9 @@ static char *MSUBU_DSP_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MSUBU %s, %s, %s", ac, rs, rt);
 }
@@ -10573,9 +10582,9 @@ static char *MTC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MTC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10596,8 +10605,8 @@ static char *MTC1(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("MTC1 %s, %s", rt, fs);
 }
@@ -10618,8 +10627,8 @@ static char *MTC2(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("MTC2 %s, %s", rt, cs);
 }
@@ -10641,9 +10650,9 @@ static char *MTGC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MTGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10665,9 +10674,9 @@ static char *MTHC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MTHC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10688,8 +10697,8 @@ static char *MTHC1(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("MTHC1 %s, %s", rt, fs);
 }
@@ -10710,8 +10719,8 @@ static char *MTHC2(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *cs = CPR(copy(cs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("MTHC2 %s, %s", rt, cs);
 }
@@ -10733,9 +10742,9 @@ static char *MTHGC0(uint64 instruction, img_address m_pc)
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = CPR(copy(c0s_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = CPR(copy_ui(c0s_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MTHGC0 %s, %s, %s", rt, c0s, sel);
 }
@@ -10755,8 +10764,8 @@ static char *MTHI_DSP_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *ac = AC(copy_ui(ac_value));
 
     return img_format("MTHI %s, %s", rs, ac);
 }
@@ -10776,8 +10785,8 @@ static char *MTHLIP(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *ac = AC(copy_ui(ac_value));
 
     return img_format("MTHLIP %s, %s", rs, ac);
 }
@@ -10800,10 +10809,10 @@ static char *MTHTR(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = IMMEDIATE(copy(c0s_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = IMMEDIATE_UI(copy_ui(c0s_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -10823,8 +10832,8 @@ static char *MTLO_DSP_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *ac = AC(copy_ui(ac_value));
 
     return img_format("MTLO %s, %s", rs, ac);
 }
@@ -10847,10 +10856,10 @@ static char *MTTR(uint64 instruction, img_address m_pc)
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *c0s = IMMEDIATE(copy(c0s_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *c0s = IMMEDIATE_UI(copy_ui(c0s_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
 }
@@ -10872,9 +10881,9 @@ static char *MUH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MUH %s, %s, %s", rd, rs, rt);
 }
@@ -10896,9 +10905,9 @@ static char *MUHU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MUHU %s, %s, %s", rd, rs, rt);
 }
@@ -10920,9 +10929,9 @@ static char *MUL_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MUL %s, %s, %s", rd, rs, rt);
 }
@@ -10966,9 +10975,9 @@ static char *MUL_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MUL.D %s, %s, %s", fd, fs, ft);
 }
@@ -10991,9 +11000,9 @@ static char *MUL_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MUL.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11016,9 +11025,9 @@ static char *MUL_S_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MUL_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11040,9 +11049,9 @@ static char *MUL_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("MUL.S %s, %s, %s", fd, fs, ft);
 }
@@ -11065,9 +11074,9 @@ static char *MULEQ_S_W_PHL(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
 }
@@ -11090,9 +11099,9 @@ static char *MULEQ_S_W_PHR(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
 }
@@ -11115,9 +11124,9 @@ static char *MULEU_S_PH_QBL(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
 }
@@ -11140,9 +11149,9 @@ static char *MULEU_S_PH_QBR(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
 }
@@ -11165,9 +11174,9 @@ static char *MULQ_RS_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11190,9 +11199,9 @@ static char *MULQ_RS_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
 }
@@ -11215,9 +11224,9 @@ static char *MULQ_S_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11240,9 +11249,9 @@ static char *MULQ_S_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULQ_S.W %s, %s, %s", rd, rs, rt);
 }
@@ -11265,9 +11274,9 @@ static char *MULSA_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -11290,9 +11299,9 @@ static char *MULSAQ_S_W_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -11314,9 +11323,9 @@ static char *MULT_DSP_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULT %s, %s, %s", ac, rs, rt);
 }
@@ -11338,9 +11347,9 @@ static char *MULTU_DSP_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy(ac_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULTU %s, %s, %s", ac, rs, rt);
 }
@@ -11362,9 +11371,9 @@ static char *MULU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("MULU %s, %s, %s", rd, rs, rt);
 }
@@ -11385,8 +11394,8 @@ static char *NEG_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("NEG.D %s, %s", ft, fs);
 }
@@ -11407,8 +11416,8 @@ static char *NEG_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("NEG.S %s, %s", ft, fs);
 }
@@ -11466,9 +11475,9 @@ static char *NOR(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("NOR %s, %s, %s", rd, rs, rt);
 }
@@ -11534,9 +11543,9 @@ static char *OR_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("OR %s, %s, %s", rd, rs, rt);
 }
@@ -11558,9 +11567,9 @@ static char *ORI(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ORI %s, %s, %s", rt, rs, u);
 }
@@ -11583,9 +11592,9 @@ static char *PACKRL_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("PACKRL.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11626,9 +11635,9 @@ static char *PICK_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("PICK.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11651,9 +11660,9 @@ static char *PICK_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("PICK.QB %s, %s, %s", rd, rs, rt);
 }
@@ -11675,8 +11684,8 @@ static char *PRECEQ_W_PHL(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PRECEQ.W.PHL %s, %s", rt, rs);
 }
@@ -11698,8 +11707,8 @@ static char *PRECEQ_W_PHR(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PRECEQ.W.PHR %s, %s", rt, rs);
 }
@@ -11721,8 +11730,8 @@ static char *PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PRECEQU.PH.QBLA %s, %s", rt, rs);
 }
@@ -11744,8 +11753,8 @@ static char *PRECEQU_PH_QBL(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PRECEQU.PH.QBL %s, %s", rt, rs);
 }
@@ -11767,8 +11776,8 @@ static char *PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PRECEQU.PH.QBRA %s, %s", rt, rs);
 }
@@ -11790,8 +11799,8 @@ static char *PRECEQU_PH_QBR(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PRECEQU.PH.QBR %s, %s", rt, rs);
 }
@@ -11814,8 +11823,8 @@ static char *PRECEU_PH_QBLA(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PRECEU.PH.QBLA %s, %s", rt, rs);
 }
@@ -11837,8 +11846,8 @@ static char *PRECEU_PH_QBL(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PRECEU.PH.QBL %s, %s", rt, rs);
 }
@@ -11861,8 +11870,8 @@ static char *PRECEU_PH_QBRA(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PRECEU.PH.QBRA %s, %s", rt, rs);
 }
@@ -11884,8 +11893,8 @@ static char *PRECEU_PH_QBR(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PRECEU.PH.QBR %s, %s", rt, rs);
 }
@@ -11908,9 +11917,9 @@ static char *PRECR_QB_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11933,9 +11942,9 @@ static char *PRECR_SRA_PH_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
 }
@@ -11958,9 +11967,9 @@ static char *PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
 }
@@ -11983,9 +11992,9 @@ static char *PRECRQ_PH_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
 }
@@ -12008,9 +12017,9 @@ static char *PRECRQ_QB_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
 }
@@ -12033,9 +12042,9 @@ static char *PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
 }
@@ -12058,9 +12067,9 @@ static char *PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
 }
@@ -12082,9 +12091,9 @@ static char *PREF_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *hint = IMMEDIATE(copy(hint_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *hint = IMMEDIATE_UI(copy_ui(hint_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PREF %s, %s(%s)", hint, s, rs);
 }
@@ -12106,9 +12115,9 @@ static char *PREF_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *hint = IMMEDIATE(copy(hint_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *hint = IMMEDIATE_UI(copy_ui(hint_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PREF %s, %s(%s)", hint, u, rs);
 }
@@ -12130,9 +12139,9 @@ static char *PREFE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *hint = IMMEDIATE(copy(hint_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *hint = IMMEDIATE_UI(copy_ui(hint_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("PREFE %s, %s(%s)", hint, s, rs);
 }
@@ -12154,9 +12163,9 @@ static char *PREPEND(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("PREPEND %s, %s, %s", rt, rs, sa);
 }
@@ -12176,8 +12185,8 @@ static char *RADDU_W_QB(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("RADDU.W.QB %s, %s", rt, rs);
 }
@@ -12197,8 +12206,8 @@ static char *RDDSP(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *mask = IMMEDIATE(copy(mask_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *mask = IMMEDIATE_UI(copy_ui(mask_value));
 
     return img_format("RDDSP %s, %s", rt, mask);
 }
@@ -12220,9 +12229,9 @@ static char *RDHWR(uint64 instruction, img_address m_pc)
     uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *hs = CPR(copy(hs_value));
-    g_autofree char *sel = IMMEDIATE(copy(sel_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *hs = CPR(copy_ui(hs_value));
+    g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
     return img_format("RDHWR %s, %s, %s", rt, hs, sel);
 }
@@ -12243,8 +12252,8 @@ static char *RDPGPR(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("RDPGPR %s, %s", rt, rs);
 }
@@ -12265,8 +12274,8 @@ static char *RECIP_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("RECIP.D %s, %s", ft, fs);
 }
@@ -12287,8 +12296,8 @@ static char *RECIP_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("RECIP.S %s, %s", ft, fs);
 }
@@ -12309,8 +12318,8 @@ static char *REPL_PH(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se9_20_19_18_17_16_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("REPL.PH %s, %s", rt, s);
 }
@@ -12331,8 +12340,8 @@ static char *REPL_QB(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("REPL.QB %s, %s", rt, u);
 }
@@ -12353,8 +12362,8 @@ static char *REPLV_PH(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("REPLV.PH %s, %s", rt, rs);
 }
@@ -12374,8 +12383,8 @@ static char *REPLV_QB(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("REPLV.QB %s, %s", rt, rs);
 }
@@ -12398,7 +12407,7 @@ static char *RESTORE_32_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
     uint64 gp_value = extract_gp_2(instruction);
 
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *save_restore_str = save_restore_list(
         rt_value, count_value, gp_value);
     return img_format("RESTORE %s%s", u, save_restore_str);
@@ -12421,7 +12430,7 @@ static char *RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
     uint64 count_value = extract_count_3_2_1_0(instruction);
 
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *save_restore_str = save_restore_list(
         encode_rt1_from_rt(rt1_value), count_value, 0);
     return img_format("RESTORE.JRC %s%s", u, save_restore_str);
@@ -12445,7 +12454,7 @@ static char *RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
     uint64 gp_value = extract_gp_2(instruction);
 
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *save_restore_str = save_restore_list(
         rt_value, count_value, gp_value);
     return img_format("RESTORE.JRC %s%s", u, save_restore_str);
@@ -12467,8 +12476,8 @@ static char *RESTOREF(uint64 instruction, img_address m_pc)
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
 
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    g_autofree char *count = IMMEDIATE(copy(count_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    g_autofree char *count = IMMEDIATE_UI(copy_ui(count_value));
 
     return img_format("RESTOREF %s, %s", u, count);
 }
@@ -12489,8 +12498,8 @@ static char *RINT_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("RINT.D %s, %s", ft, fs);
 }
@@ -12511,8 +12520,8 @@ static char *RINT_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("RINT.S %s, %s", ft, fs);
 }
@@ -12534,9 +12543,9 @@ static char *ROTR(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("ROTR %s, %s, %s", rt, rs, shift);
 }
@@ -12558,9 +12567,9 @@ static char *ROTRV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("ROTRV %s, %s, %s", rd, rs, rt);
 }
@@ -12584,11 +12593,11 @@ static char *ROTX(uint64 instruction, img_address m_pc)
     uint64 stripe_value = extract_stripe_6(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
-    g_autofree char *shiftx = IMMEDIATE(copy(shiftx_value));
-    g_autofree char *stripe = IMMEDIATE(copy(stripe_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
+    g_autofree char *shiftx = IMMEDIATE_UI(copy_ui(shiftx_value));
+    g_autofree char *stripe = IMMEDIATE_UI(copy_ui(stripe_value));
 
     return img_format("ROTX %s, %s, %s, %s, %s",
                        rt, rs, shift, shiftx, stripe);
@@ -12610,8 +12619,8 @@ static char *ROUND_L_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("ROUND.L.D %s, %s", ft, fs);
 }
@@ -12632,8 +12641,8 @@ static char *ROUND_L_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("ROUND.L.S %s, %s", ft, fs);
 }
@@ -12654,8 +12663,8 @@ static char *ROUND_W_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("ROUND.W.D %s, %s", ft, fs);
 }
@@ -12676,8 +12685,8 @@ static char *ROUND_W_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("ROUND.W.S %s, %s", ft, fs);
 }
@@ -12698,8 +12707,8 @@ static char *RSQRT_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("RSQRT.D %s, %s", ft, fs);
 }
@@ -12720,8 +12729,8 @@ static char *RSQRT_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("RSQRT.S %s, %s", ft, fs);
 }
@@ -12743,7 +12752,7 @@ static char *SAVE_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
     uint64 count_value = extract_count_3_2_1_0(instruction);
 
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *save_restore_str = save_restore_list(
         encode_rt1_from_rt(rt1_value), count_value, 0);
     return img_format("SAVE %s%s", u, save_restore_str);
@@ -12767,7 +12776,7 @@ static char *SAVE_32_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
     uint64 gp_value = extract_gp_2(instruction);
 
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *save_restore_str = save_restore_list(
         rt_value, count_value, gp_value);
     return img_format("SAVE %s%s", u, save_restore_str);
@@ -12789,8 +12798,8 @@ static char *SAVEF(uint64 instruction, img_address m_pc)
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
 
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    g_autofree char *count = IMMEDIATE(copy(count_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    g_autofree char *count = IMMEDIATE_UI(copy_ui(count_value));
 
     return img_format("SAVEF %s, %s", u, count);
 }
@@ -12813,7 +12822,7 @@ static char *SB_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_1_0(instruction);
 
     const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("SB %s, %s(%s)", rtz3, u, rs3);
@@ -12835,8 +12844,8 @@ static char *SB_GP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SB %s, %s($%d)", rt, u, 28);
 }
@@ -12858,9 +12867,9 @@ static char *SB_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SB %s, %s(%s)", rt, s, rs);
 }
@@ -12882,9 +12891,9 @@ static char *SB_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SB %s, %s(%s)", rt, u, rs);
 }
@@ -12906,9 +12915,9 @@ static char *SBE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SBE %s, %s(%s)", rt, s, rs);
 }
@@ -12930,9 +12939,9 @@ static char *SBX(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SBX %s, %s(%s)", rd, rs, rt);
 }
@@ -12954,9 +12963,9 @@ static char *SC(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SC %s, %s(%s)", rt, s, rs);
 }
@@ -12978,9 +12987,9 @@ static char *SCD(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SCD %s, %s(%s)", rt, s, rs);
 }
@@ -13002,9 +13011,9 @@ static char *SCDP(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ru = GPR(copy(ru_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ru = GPR(copy_ui(ru_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SCDP %s, %s, (%s)", rt, ru, rs);
 }
@@ -13026,9 +13035,9 @@ static char *SCE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SCE %s, %s(%s)", rt, s, rs);
 }
@@ -13050,9 +13059,9 @@ static char *SCWP(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ru = GPR(copy(ru_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ru = GPR(copy_ui(ru_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SCWP %s, %s, (%s)", rt, ru, rs);
 }
@@ -13074,9 +13083,9 @@ static char *SCWPE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *ru = GPR(copy(ru_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *ru = GPR(copy_ui(ru_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SCWPE %s, %s, (%s)", rt, ru, rs);
 }
@@ -13097,8 +13106,8 @@ static char *SD_GP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_3__s3(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SD %s, %s($%d)", rt, u, 28);
 }
@@ -13120,9 +13129,9 @@ static char *SD_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SD %s, %s(%s)", rt, s, rs);
 }
@@ -13144,9 +13153,9 @@ static char *SD_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SD %s, %s(%s)", rt, u, rs);
 }
@@ -13166,7 +13175,7 @@ static char *SDBBP_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
-    g_autofree char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE_UI(copy_ui(code_value));
 
     return img_format("SDBBP %s", code);
 }
@@ -13186,7 +13195,7 @@ static char *SDBBP_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
-    g_autofree char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE_UI(copy_ui(code_value));
 
     return img_format("SDBBP %s", code);
 }
@@ -13207,8 +13216,8 @@ static char *SDC1_GP_(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SDC1 %s, %s($%d)", ft, u, 28);
 }
@@ -13230,9 +13239,9 @@ static char *SDC1_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SDC1 %s, %s(%s)", ft, s, rs);
 }
@@ -13254,9 +13263,9 @@ static char *SDC1_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SDC1 %s, %s(%s)", ft, u, rs);
 }
@@ -13278,9 +13287,9 @@ static char *SDC1X(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SDC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -13302,9 +13311,9 @@ static char *SDC1XS(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SDC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -13326,9 +13335,9 @@ static char *SDC2(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *cs = CPR(copy(cs_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SDC2 %s, %s(%s)", cs, s, rs);
 }
@@ -13351,10 +13360,11 @@ static char *SDM(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
+        count3_value));
 
     return img_format("SDM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -13375,7 +13385,7 @@ static char *SDPC_48_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("SDPC %s, %s", rt, s);
@@ -13398,9 +13408,9 @@ static char *SDXS(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SDXS %s, %s(%s)", rd, rs, rt);
 }
@@ -13422,9 +13432,9 @@ static char *SDX(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SDX %s, %s(%s)", rd, rs, rt);
 }
@@ -13445,8 +13455,8 @@ static char *SEB(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SEB %s, %s", rt, rs);
 }
@@ -13467,8 +13477,8 @@ static char *SEH(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SEH %s, %s", rt, rs);
 }
@@ -13490,9 +13500,9 @@ static char *SEL_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("SEL.D %s, %s, %s", fd, fs, ft);
 }
@@ -13514,9 +13524,9 @@ static char *SEL_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("SEL.S %s, %s, %s", fd, fs, ft);
 }
@@ -13538,9 +13548,9 @@ static char *SELEQZ_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("SELEQZ.D %s, %s, %s", fd, fs, ft);
 }
@@ -13562,9 +13572,9 @@ static char *SELEQZ_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("SELEQZ.S %s, %s, %s", fd, fs, ft);
 }
@@ -13586,9 +13596,9 @@ static char *SELNEZ_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("SELNEZ.D %s, %s, %s", fd, fs, ft);
 }
@@ -13610,9 +13620,9 @@ static char *SELNEZ_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("SELNEZ.S %s, %s, %s", fd, fs, ft);
 }
@@ -13634,9 +13644,9 @@ static char *SEQI(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SEQI %s, %s, %s", rt, rs, u);
 }
@@ -13659,7 +13669,7 @@ static char *SH_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_2_1__s1(instruction);
 
     const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("SH %s, %s(%s)", rtz3, u, rs3);
@@ -13681,8 +13691,8 @@ static char *SH_GP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SH %s, %s($%d)", rt, u, 28);
 }
@@ -13704,9 +13714,9 @@ static char *SH_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SH %s, %s(%s)", rt, s, rs);
 }
@@ -13728,9 +13738,9 @@ static char *SH_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SH %s, %s(%s)", rt, u, rs);
 }
@@ -13752,9 +13762,9 @@ static char *SHE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHE %s, %s(%s)", rt, s, rs);
 }
@@ -13775,8 +13785,8 @@ static char *SHILO(uint64 instruction, img_address m_pc)
     int64 shift_value = extract_shift__se5_21_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
-    const char *ac = AC(copy(ac_value));
+    g_autofree char *shift = IMMEDIATE_I(copy_i(shift_value));
+    const char *ac = AC(copy_ui(ac_value));
 
     return img_format("SHILO %s, %s", ac, shift);
 }
@@ -13797,8 +13807,8 @@ static char *SHILOV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *ac = AC(copy(ac_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *ac = AC(copy_ui(ac_value));
 
     return img_format("SHILOV %s, %s", ac, rs);
 }
@@ -13820,9 +13830,9 @@ static char *SHLL_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHLL.PH %s, %s, %s", rt, rs, sa);
 }
@@ -13844,9 +13854,9 @@ static char *SHLL_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHLL.QB %s, %s, %s", rt, rs, sa);
 }
@@ -13869,9 +13879,9 @@ static char *SHLL_S_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
 }
@@ -13893,9 +13903,9 @@ static char *SHLL_S_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHLL_S.W %s, %s, %s", rt, rs, sa);
 }
@@ -13918,9 +13928,9 @@ static char *SHLLV_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHLLV.PH %s, %s, %s", rd, rt, rs);
 }
@@ -13942,9 +13952,9 @@ static char *SHLLV_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHLLV.QB %s, %s, %s", rd, rt, rs);
 }
@@ -13967,9 +13977,9 @@ static char *SHLLV_S_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
 }
@@ -13991,9 +14001,9 @@ static char *SHLLV_S_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
 }
@@ -14015,9 +14025,9 @@ static char *SHRA_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRA.PH %s, %s, %s", rt, rs, sa);
 }
@@ -14039,9 +14049,9 @@ static char *SHRA_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRA.QB %s, %s, %s", rt, rs, sa);
 }
@@ -14063,9 +14073,9 @@ static char *SHRA_R_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
 }
@@ -14087,9 +14097,9 @@ static char *SHRA_R_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
 }
@@ -14111,9 +14121,9 @@ static char *SHRA_R_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRA_R.W %s, %s, %s", rt, rs, sa);
 }
@@ -14135,9 +14145,9 @@ static char *SHRAV_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHRAV.PH %s, %s, %s", rd, rt, rs);
 }
@@ -14159,9 +14169,9 @@ static char *SHRAV_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHRAV.QB %s, %s, %s", rd, rt, rs);
 }
@@ -14183,9 +14193,9 @@ static char *SHRAV_R_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
 }
@@ -14207,9 +14217,9 @@ static char *SHRAV_R_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
 }
@@ -14231,9 +14241,9 @@ static char *SHRAV_R_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
 }
@@ -14255,9 +14265,9 @@ static char *SHRL_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRL.PH %s, %s, %s", rt, rs, sa);
 }
@@ -14279,9 +14289,9 @@ static char *SHRL_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *sa = IMMEDIATE(copy(sa_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRL.QB %s, %s, %s", rt, rs, sa);
 }
@@ -14304,9 +14314,9 @@ static char *SHRLV_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHRLV.PH %s, %s, %s", rd, rt, rs);
 }
@@ -14328,9 +14338,9 @@ static char *SHRLV_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SHRLV.QB %s, %s, %s", rd, rt, rs);
 }
@@ -14352,9 +14362,9 @@ static char *SHX(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SHX %s, %s(%s)", rd, rs, rt);
 }
@@ -14376,9 +14386,9 @@ static char *SHXS(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SHXS %s, %s(%s)", rd, rs, rt);
 }
@@ -14398,7 +14408,7 @@ static char *SIGRIE(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
-    g_autofree char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE_UI(copy_ui(code_value));
 
     return img_format("SIGRIE %s", code);
 }
@@ -14422,7 +14432,8 @@ static char *SLL_16_(uint64 instruction, img_address m_pc)
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    g_autofree char *shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
+    g_autofree char *shift3 = IMMEDIATE_UI(encode_shift3_from_shift(
+        shift3_value));
 
     return img_format("SLL %s, %s, %s", rt3, rs3, shift3);
 }
@@ -14444,9 +14455,9 @@ static char *SLL_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("SLL %s, %s, %s", rt, rs, shift);
 }
@@ -14468,9 +14479,9 @@ static char *SLLV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SLLV %s, %s, %s", rd, rs, rt);
 }
@@ -14492,9 +14503,9 @@ static char *SLT(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SLT %s, %s, %s", rd, rs, rt);
 }
@@ -14516,9 +14527,9 @@ static char *SLTI(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SLTI %s, %s, %s", rt, rs, u);
 }
@@ -14540,9 +14551,9 @@ static char *SLTIU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SLTIU %s, %s, %s", rt, rs, u);
 }
@@ -14564,9 +14575,9 @@ static char *SLTU(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SLTU %s, %s, %s", rd, rs, rt);
 }
@@ -14588,9 +14599,9 @@ static char *SOV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SOV %s, %s, %s", rd, rs, rt);
 }
@@ -14610,7 +14621,7 @@ static char *SPECIAL2(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
-    g_autofree char *op = IMMEDIATE(copy(op_value));
+    g_autofree char *op = IMMEDIATE_UI(copy_ui(op_value));
 
     return img_format("SPECIAL2 %s", op);
 }
@@ -14631,8 +14642,8 @@ static char *SQRT_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("SQRT.D %s, %s", ft, fs);
 }
@@ -14653,8 +14664,8 @@ static char *SQRT_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("SQRT.S %s, %s", ft, fs);
 }
@@ -14676,9 +14687,9 @@ static char *SRA(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("SRA %s, %s, %s", rt, rs, shift);
 }
@@ -14700,9 +14711,9 @@ static char *SRAV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SRAV %s, %s, %s", rd, rs, rt);
 }
@@ -14726,7 +14737,8 @@ static char *SRL_16_(uint64 instruction, img_address m_pc)
 
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    g_autofree char *shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
+    g_autofree char *shift3 = IMMEDIATE_UI(encode_shift3_from_shift(
+        shift3_value));
 
     return img_format("SRL %s, %s, %s", rt3, rs3, shift3);
 }
@@ -14748,9 +14760,9 @@ static char *SRL_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *shift = IMMEDIATE(copy(shift_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("SRL %s, %s, %s", rt, rs, shift);
 }
@@ -14772,9 +14784,9 @@ static char *SRLV(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SRLV %s, %s, %s", rd, rs, rt);
 }
@@ -14796,9 +14808,9 @@ static char *SUB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUB %s, %s, %s", rd, rs, rt);
 }
@@ -14820,9 +14832,9 @@ static char *SUB_D(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("SUB.D %s, %s, %s", fd, fs, ft);
 }
@@ -14844,9 +14856,9 @@ static char *SUB_S(uint64 instruction, img_address m_pc)
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy(fd_value));
-    const char *fs = FPR(copy(fs_value));
-    const char *ft = FPR(copy(ft_value));
+    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
 
     return img_format("SUB.S %s, %s, %s", fd, fs, ft);
 }
@@ -14868,9 +14880,9 @@ static char *SUBQ_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBQ.PH %s, %s, %s", rd, rs, rt);
 }
@@ -14893,9 +14905,9 @@ static char *SUBQ_S_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -14918,9 +14930,9 @@ static char *SUBQ_S_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
 }
@@ -14943,9 +14955,9 @@ static char *SUBQH_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBQH.PH %s, %s, %s", rd, rs, rt);
 }
@@ -14968,9 +14980,9 @@ static char *SUBQH_R_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
 }
@@ -14993,9 +15005,9 @@ static char *SUBQH_R_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
 }
@@ -15018,9 +15030,9 @@ static char *SUBQH_W(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBQH.W %s, %s, %s", rd, rs, rt);
 }
@@ -15066,9 +15078,9 @@ static char *SUBU_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBU %s, %s, %s", rd, rs, rt);
 }
@@ -15090,9 +15102,9 @@ static char *SUBU_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBU.PH %s, %s, %s", rd, rs, rt);
 }
@@ -15114,9 +15126,9 @@ static char *SUBU_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBU.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15139,9 +15151,9 @@ static char *SUBU_S_PH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -15164,9 +15176,9 @@ static char *SUBU_S_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15189,9 +15201,9 @@ static char *SUBUH_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBUH.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15214,9 +15226,9 @@ static char *SUBUH_R_QB(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15239,7 +15251,7 @@ static char *SW_16_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_3_2_1_0__s2(instruction);
 
     const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
 
     return img_format("SW %s, %s(%s)", rtz3, u, rs3);
@@ -15263,7 +15275,7 @@ static char *SW_4X4_(uint64 instruction, img_address m_pc)
     uint64 u_value = extract_u_3_8__s2(instruction);
 
     const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
 
     return img_format("SW %s, %s(%s)", rtz4, u, rs4);
@@ -15286,7 +15298,7 @@ static char *SW_GP16_(uint64 instruction, img_address m_pc)
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
 
     const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SW %s, %s($%d)", rtz3, u, 28);
 }
@@ -15307,8 +15319,8 @@ static char *SW_GP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SW %s, %s($%d)", rt, u, 28);
 }
@@ -15330,9 +15342,9 @@ static char *SW_S9_(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SW %s, %s(%s)", rt, s, rs);
 }
@@ -15353,8 +15365,8 @@ static char *SW_SP_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SW %s, %s($%d)", rt, u, 29);
 }
@@ -15376,9 +15388,9 @@ static char *SW_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SW %s, %s(%s)", rt, u, rs);
 }
@@ -15399,8 +15411,8 @@ static char *SWC1_GP_(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SWC1 %s, %s($%d)", ft, u, 28);
 }
@@ -15422,9 +15434,9 @@ static char *SWC1_S9_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SWC1 %s, %s(%s)", ft, s, rs);
 }
@@ -15446,9 +15458,9 @@ static char *SWC1_U12_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SWC1 %s, %s(%s)", ft, u, rs);
 }
@@ -15470,9 +15482,9 @@ static char *SWC1X(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SWC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -15494,9 +15506,9 @@ static char *SWC1XS(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SWC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -15518,9 +15530,9 @@ static char *SWC2(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *cs = CPR(copy(cs_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *cs = CPR(copy_ui(cs_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SWC2 %s, %s(%s)", cs, s, rs);
 }
@@ -15542,9 +15554,9 @@ static char *SWE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SWE %s, %s(%s)", rt, s, rs);
 }
@@ -15567,10 +15579,11 @@ static char *SWM(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
+        count3_value));
 
     return img_format("SWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -15591,7 +15604,7 @@ static char *SWPC_48_(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
+    const char *rt = GPR(copy_ui(rt_value));
     g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
 
     return img_format("SWPC %s, %s", rt, s);
@@ -15614,9 +15627,9 @@ static char *SWX(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SWX %s, %s(%s)", rd, rs, rt);
 }
@@ -15638,9 +15651,9 @@ static char *SWXS(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("SWXS %s, %s(%s)", rd, rs, rt);
 }
@@ -15660,7 +15673,7 @@ static char *SYNC(uint64 instruction, img_address m_pc)
 {
     uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
 
-    g_autofree char *stype = IMMEDIATE(copy(stype_value));
+    g_autofree char *stype = IMMEDIATE_UI(copy_ui(stype_value));
 
     return img_format("SYNC %s", stype);
 }
@@ -15681,8 +15694,8 @@ static char *SYNCI(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SYNCI %s(%s)", s, rs);
 }
@@ -15703,8 +15716,8 @@ static char *SYNCIE(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("SYNCIE %s(%s)", s, rs);
 }
@@ -15724,7 +15737,7 @@ static char *SYSCALL_16_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
-    g_autofree char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE_UI(copy_ui(code_value));
 
     return img_format("SYSCALL %s", code);
 }
@@ -15742,7 +15755,7 @@ static char *SYSCALL_32_(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
-    g_autofree char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE_UI(copy_ui(code_value));
 
     return img_format("SYSCALL %s", code);
 }
@@ -15763,8 +15776,8 @@ static char *TEQ(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("TEQ %s, %s", rs, rt);
 }
@@ -16001,8 +16014,8 @@ static char *TNE(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("TNE %s, %s", rs, rt);
 }
@@ -16023,8 +16036,8 @@ static char *TRUNC_L_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("TRUNC.L.D %s, %s", ft, fs);
 }
@@ -16045,8 +16058,8 @@ static char *TRUNC_L_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("TRUNC.L.S %s, %s", ft, fs);
 }
@@ -16067,8 +16080,8 @@ static char *TRUNC_W_D(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("TRUNC.W.D %s, %s", ft, fs);
 }
@@ -16089,8 +16102,8 @@ static char *TRUNC_W_S(uint64 instruction, img_address m_pc)
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy(ft_value));
-    const char *fs = FPR(copy(fs_value));
+    const char *ft = FPR(copy_ui(ft_value));
+    const char *fs = FPR(copy_ui(fs_value));
 
     return img_format("TRUNC.W.S %s, %s", ft, fs);
 }
@@ -16113,10 +16126,11 @@ static char *UALDM(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
+        count3_value));
 
     return img_format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16138,9 +16152,9 @@ static char *UALH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("UALH %s, %s(%s)", rt, s, rs);
 }
@@ -16163,10 +16177,11 @@ static char *UALWM(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
+        count3_value));
 
     return img_format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16189,10 +16204,11 @@ static char *UASDM(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
+        count3_value));
 
     return img_format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16214,9 +16230,9 @@ static char *UASH(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("UASH %s, %s(%s)", rt, s, rs);
 }
@@ -16239,10 +16255,11 @@ static char *UASWM(uint64 instruction, img_address m_pc)
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *s = IMMEDIATE(copy(s_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
+        count3_value));
 
     return img_format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
 }
@@ -16262,7 +16279,7 @@ static char *UDI(uint64 instruction, img_address m_pc)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
-    g_autofree char *op = IMMEDIATE(copy(op_value));
+    g_autofree char *op = IMMEDIATE_UI(copy_ui(op_value));
 
     return img_format("UDI %s", op);
 }
@@ -16280,7 +16297,7 @@ static char *WAIT(uint64 instruction, img_address m_pc)
 {
     uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
 
-    g_autofree char *code = IMMEDIATE(copy(code_value));
+    g_autofree char *code = IMMEDIATE_UI(copy_ui(code_value));
 
     return img_format("WAIT %s", code);
 }
@@ -16301,8 +16318,8 @@ static char *WRDSP(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    g_autofree char *mask = IMMEDIATE(copy(mask_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    g_autofree char *mask = IMMEDIATE_UI(copy_ui(mask_value));
 
     return img_format("WRDSP %s, %s", rt, mask);
 }
@@ -16323,8 +16340,8 @@ static char *WRPGPR(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("WRPGPR %s, %s", rt, rs);
 }
@@ -16368,9 +16385,9 @@ static char *XOR_32_(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy(rd_value));
-    const char *rs = GPR(copy(rs_value));
-    const char *rt = GPR(copy(rt_value));
+    const char *rd = GPR(copy_ui(rd_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
 
     return img_format("XOR %s, %s, %s", rd, rs, rt);
 }
@@ -16392,9 +16409,9 @@ static char *XORI(uint64 instruction, img_address m_pc)
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
-    g_autofree char *u = IMMEDIATE(copy(u_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
+    g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("XORI %s, %s, %s", rt, rs, u);
 }
@@ -16414,8 +16431,8 @@ static char *YIELD(uint64 instruction, img_address m_pc)
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy(rt_value));
-    const char *rs = GPR(copy(rs_value));
+    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value));
 
     return img_format("YIELD %s, %s", rt, rs);
 }
@@ -22218,11 +22235,6 @@ static struct Pool MAJOR[2] = {
        0x0                 },        /* P16 */
 };
 
-static int Disassemble(const uint16 *data, char *dis,
-                       TABLE_ENTRY_TYPE & type, img_address m_pc)
-{
-    return Disassemble(data, dis, type, MAJOR, 2, m_pc);
-}
 
 static int nanomips_dis(char *buf,
                  unsigned address,
@@ -22234,7 +22246,7 @@ static int nanomips_dis(char *buf,
     uint16 bits[3] = {one, two, three};
 
     TABLE_ENTRY_TYPE type;
-    int size = Disassemble(bits, disasm, type, address);
+    int size = Disassemble(bits, disasm, type, MAJOR, 2, address);
 
     strcpy(buf, disasm);
     return size;
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 14/20] disas/nanomips: Remove function overloading
  2022-09-05  9:55 ` [PATCH v2 14/20] disas/nanomips: Remove function overloading Milica Lazarevic
@ 2022-09-05 11:43   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:43 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> -static uint64 copy(uint64 d)
> +static uint64 copy_ui(uint64 d)
>   {
>       return d;
>   }
>   
>   
> -static int64 copy(int64 d)
> +static int64 copy_i(int64 d)
>   {
>       return d;
>   }

These functions can surely just be removed.


> -static char *IMMEDIATE(uint64 value)
> +static char *IMMEDIATE_UI(uint64 value)
>  {
>      return img_format("0x%" PRIx64, value);
>  }
>  
>  
> -static char *IMMEDIATE(int64 value)
> +static char *IMMEDIATE_I(int64 value)
>  {
>      return img_format("%" PRId64, value);
>  }

And these would be removed by the previous conversion to direct use of printf values by 
the individual instructions.


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 15/20] disas/nanomips: Introduce Dis_info struct
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (13 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 14/20] disas/nanomips: Remove function overloading Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:55   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 16/20] disas/nanomips: Replace exception handling Milica Lazarevic
                   ` (4 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

This patch introduces the Dis_info struct, which should hold the
necessary data for handling runtime errors. Fields fprintf_func and
stream are in charge of error printing. Field buf enables the use of
sigsetjmp() and siglongjmp() functions. Support for runtime error
handling will be added later.

Parameter m_pc, which we need for address calculation, is integrated
into the Dis_info struct.

We're filling Dis_info at the entrance of the nanoMIPS disassembler,
i.e. print_insn_nanomips. Next, we're adding that information as an
argument wherever we need to.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
---
 disas/nanomips.cpp | 4083 ++++++++++++++++++++++----------------------
 1 file changed, 2050 insertions(+), 2033 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index 9e34ca164c..5142f307fc 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -41,9 +41,16 @@ typedef uint32_t uint32;
 typedef uint16_t uint16;
 typedef uint64_t img_address;
 
+struct Dis_info {
+  img_address m_pc;
+  fprintf_function fprintf_func;
+  FILE *stream;
+  sigjmp_buf buf;
+};
+
 typedef bool (*conditional_function)(uint64 instruction);
 typedef char * (*disassembly_function)(uint64 instruction,
-                                       img_address m_pc);
+                                       struct Dis_info *info);
 
 enum TABLE_ENTRY_TYPE {
     instruction,
@@ -86,6 +93,7 @@ struct Pool {
     uint64               attributes;
 };
 
+
 #define IMGASSERTONCE(test)
 
 
@@ -120,7 +128,7 @@ static int64 sign_extend(int64 data, int msb)
 
 
 static uint64 renumber_registers(uint64 index, uint64 *register_list,
-                               size_t register_list_size)
+                            size_t register_list_size, struct Dis_info *info)
 {
     if (index < register_list_size) {
         return register_list[index];
@@ -159,12 +167,12 @@ static uint64 renumber_registers(uint64 index, uint64 *register_list,
  *     - MUL[4X4]
  *     - SW[4X4]
  */
-static uint64 decode_gpr_gpr4(uint64 d)
+static uint64 decode_gpr_gpr4(uint64 d, struct Dis_info *info)
 {
     static uint64 register_list[] = {  8,  9, 10, 11,  4,  5,  6,  7,
                                       16, 17, 18, 19, 20, 21, 22, 23 };
     return renumber_registers(d, register_list,
-               sizeof(register_list) / sizeof(register_list[0]));
+               sizeof(register_list) / sizeof(register_list[0]), info);
 }
 
 
@@ -195,12 +203,12 @@ static uint64 decode_gpr_gpr4(uint64 d)
  *     - MOVEP
  *     - SW[4X4]
  */
-static uint64 decode_gpr_gpr4_zero(uint64 d)
+static uint64 decode_gpr_gpr4_zero(uint64 d, struct Dis_info *info)
 {
     static uint64 register_list[] = {  8,  9, 10,  0,  4,  5,  6,  7,
                                       16, 17, 18, 19, 20, 21, 22, 23 };
     return renumber_registers(d, register_list,
-               sizeof(register_list) / sizeof(register_list[0]));
+               sizeof(register_list) / sizeof(register_list[0]), info);
 }
 
 
@@ -254,11 +262,11 @@ static uint64 decode_gpr_gpr4_zero(uint64 d)
  *     - SW[16]
  *     - XOR[16]
  */
-static uint64 decode_gpr_gpr3(uint64 d)
+static uint64 decode_gpr_gpr3(uint64 d, struct Dis_info *info)
 {
     static uint64 register_list[] = { 16, 17, 18, 19,  4,  5,  6,  7 };
     return renumber_registers(d, register_list,
-               sizeof(register_list) / sizeof(register_list[0]));
+               sizeof(register_list) / sizeof(register_list[0]), info);
 }
 
 
@@ -294,11 +302,11 @@ static uint64 decode_gpr_gpr3(uint64 d)
  *     - SW[16]
  *     - SW[GP16]
  */
-static uint64 decode_gpr_gpr3_src_store(uint64 d)
+static uint64 decode_gpr_gpr3_src_store(uint64 d, struct Dis_info *info)
 {
     static uint64 register_list[] = {  0, 17, 18, 19,  4,  5,  6,  7 };
     return renumber_registers(d, register_list,
-               sizeof(register_list) / sizeof(register_list[0]));
+               sizeof(register_list) / sizeof(register_list[0]), info);
 }
 
 
@@ -324,11 +332,11 @@ static uint64 decode_gpr_gpr3_src_store(uint64 d)
  *     - MOVEP
  *     - MOVEP[REV]
  */
-static uint64 decode_gpr_gpr2_reg1(uint64 d)
+static uint64 decode_gpr_gpr2_reg1(uint64 d, struct Dis_info *info)
 {
     static uint64 register_list[] = {  4,  5,  6,  7 };
     return renumber_registers(d, register_list,
-               sizeof(register_list) / sizeof(register_list[0]));
+               sizeof(register_list) / sizeof(register_list[0]), info);
 }
 
 
@@ -354,11 +362,11 @@ static uint64 decode_gpr_gpr2_reg1(uint64 d)
  *     - MOVEP
  *     - MOVEP[REV]
  */
-static uint64 decode_gpr_gpr2_reg2(uint64 d)
+static uint64 decode_gpr_gpr2_reg2(uint64 d, struct Dis_info *info)
 {
     static uint64 register_list[] = {  5,  6,  7,  8 };
     return renumber_registers(d, register_list,
-               sizeof(register_list) / sizeof(register_list[0]));
+               sizeof(register_list) / sizeof(register_list[0]), info);
 }
 
 
@@ -383,11 +391,11 @@ static uint64 decode_gpr_gpr2_reg2(uint64 d)
  *
  *     - MOVE.BALC
  */
-static uint64 decode_gpr_gpr1(uint64 d)
+static uint64 decode_gpr_gpr1(uint64 d, struct Dis_info *info)
 {
     static uint64 register_list[] = {  4,  5 };
     return renumber_registers(d, register_list,
-               sizeof(register_list) / sizeof(register_list[0]));
+               sizeof(register_list) / sizeof(register_list[0]), info);
 }
 
 
@@ -410,16 +418,16 @@ static int64 neg_copy(uint64 d)
 
 
 /* strange wrapper around  gpr3 */
-static uint64 encode_rs3_and_check_rs3_ge_rt3(uint64 d)
+static uint64 encode_rs3_and_check_rs3_ge_rt3(uint64 d, struct Dis_info *info)
 {
-return decode_gpr_gpr3(d);
+return decode_gpr_gpr3(d, info);
 }
 
 
 /* strange wrapper around  gpr3 */
-static uint64 encode_rs3_and_check_rs3_lt_rt3(uint64 d)
+static uint64 encode_rs3_and_check_rs3_lt_rt3(uint64 d, struct Dis_info *info)
 {
-    return decode_gpr_gpr3(d);
+    return decode_gpr_gpr3(d, info);
 }
 
 
@@ -493,7 +501,7 @@ static uint64 encode_lsb_from_pos_and_size(uint64 d)
 }
 
 
-static const char *GPR(uint64 reg)
+static const char *GPR(uint64 reg, struct Dis_info *info)
 {
     static const char *gpr_reg[32] = {
         "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
@@ -511,7 +519,8 @@ static const char *GPR(uint64 reg)
 }
 
 
-static char *save_restore_list(uint64 rt, uint64 count, uint64 gp)
+static char *save_restore_list(uint64 rt, uint64 count, uint64 gp,
+                               struct Dis_info *info)
 {
     /*
      * Currently, this file compiles as a cpp file, so the explicit cast here
@@ -523,7 +532,7 @@ static char *save_restore_list(uint64 rt, uint64 count, uint64 gp)
     for (uint64 counter = 0; counter != count; counter++) {
         bool use_gp = gp && (counter == count - 1);
         uint64 this_rt = use_gp ? 28 : ((rt & 0x10) | (rt + counter)) & 0x1f;
-        g_autofree char *dis_str = img_format(",%s", GPR(this_rt));
+        g_autofree char *dis_str = img_format(",%s", GPR(this_rt, info), info);
         strcat(str, dis_str);
     }
 
@@ -531,7 +540,7 @@ static char *save_restore_list(uint64 rt, uint64 count, uint64 gp)
 }
 
 
-static const char *FPR(uint64 reg)
+static const char *FPR(uint64 reg, struct Dis_info *info)
 {
     static const char *fpr_reg[32] = {
         "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",
@@ -549,7 +558,7 @@ static const char *FPR(uint64 reg)
 }
 
 
-static const char *AC(uint64 reg)
+static const char *AC(uint64 reg, struct Dis_info *info)
 {
     static const char *ac_reg[4] = {
         "ac0",  "ac1",  "ac2",  "ac3"
@@ -620,7 +629,7 @@ static uint64 extract_op_code_value(const uint16 *data, int size)
  */
 static int Disassemble(const uint16 *data, char *dis,
                        TABLE_ENTRY_TYPE & type, const Pool *table,
-                       int table_size, img_address m_pc)
+                       int table_size, struct Dis_info *info)
 {
     try
     {
@@ -636,7 +645,7 @@ static int Disassemble(const uint16 *data, char *dis,
                         if (table[i].type == pool) {
                             return Disassemble(data, dis, type,
                                                table[i].next_table,
-                                               table[i].next_table_size, m_pc);
+                                               table[i].next_table_size, info);
                         } else if ((table[i].type == instruction) ||
                                    (table[i].type == call_instruction) ||
                                    (table[i].type == branch_instruction) ||
@@ -658,7 +667,7 @@ static int Disassemble(const uint16 *data, char *dis,
                                 return -6;
                             }
                             type = table[i].type;
-                            g_autofree char *dis_str = dis_fn(op_code, m_pc);
+                            g_autofree char *dis_str = dis_fn(op_code, info);
                             strcpy(dis, dis_str);
                             return table[i].instructions_size;
                         } else {
@@ -1614,13 +1623,13 @@ static bool SLTU_cond(uint64 instruction)
  *               fs -----
  *                    fd -----
  */
-static char *ABS_D(uint64 instruction, img_address m_pc)
+static char *ABS_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *fd = FPR(copy_ui(fd_value), info);
 
     return img_format("ABS.D %s, %s", fd, fs);
 }
@@ -1636,13 +1645,13 @@ static char *ABS_D(uint64 instruction, img_address m_pc)
  *               fd -----
  *                    fs -----
  */
-static char *ABS_S(uint64 instruction, img_address m_pc)
+static char *ABS_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 fd_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *fd = FPR(copy_ui(fd_value));
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *fd = FPR(copy_ui(fd_value), info);
 
     return img_format("ABS.S %s, %s", fd, fs);
 }
@@ -1658,13 +1667,13 @@ static char *ABS_S(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ABSQ_S_PH(uint64 instruction, img_address m_pc)
+static char *ABSQ_S_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("ABSQ_S.PH %s, %s", rt, rs);
 }
@@ -1680,13 +1689,13 @@ static char *ABSQ_S_PH(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ABSQ_S_QB(uint64 instruction, img_address m_pc)
+static char *ABSQ_S_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("ABSQ_S.QB %s, %s", rt, rs);
 }
@@ -1702,13 +1711,13 @@ static char *ABSQ_S_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ABSQ_S_W(uint64 instruction, img_address m_pc)
+static char *ABSQ_S_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("ABSQ_S.W %s, %s", rt, rs);
 }
@@ -1723,7 +1732,7 @@ static char *ABSQ_S_W(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ACLR(uint64 instruction, img_address m_pc)
+static char *ACLR(uint64 instruction, struct Dis_info *info)
 {
     uint64 bit_value = extract_bit_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -1731,7 +1740,7 @@ static char *ACLR(uint64 instruction, img_address m_pc)
 
     g_autofree char *bit = IMMEDIATE_UI(copy_ui(bit_value));
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("ACLR %s, %s(%s)", bit, s, rs);
 }
@@ -1746,15 +1755,15 @@ static char *ACLR(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ADD(uint64 instruction, img_address m_pc)
+static char *ADD(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADD %s, %s, %s", rd, rs, rt);
 }
@@ -1771,15 +1780,15 @@ static char *ADD(uint64 instruction, img_address m_pc)
  *               fs -----
  *                    fd -----
  */
-static char *ADD_D(uint64 instruction, img_address m_pc)
+static char *ADD_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *fd = FPR(copy_ui(fd_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *fd = FPR(copy_ui(fd_value), info);
 
     return img_format("ADD.D %s, %s, %s", fd, fs, ft);
 }
@@ -1796,15 +1805,15 @@ static char *ADD_D(uint64 instruction, img_address m_pc)
  *               fs -----
  *                    fd -----
  */
-static char *ADD_S(uint64 instruction, img_address m_pc)
+static char *ADD_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *fd = FPR(copy_ui(fd_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *fd = FPR(copy_ui(fd_value), info);
 
     return img_format("ADD.S %s, %s, %s", fd, fs, ft);
 }
@@ -1819,14 +1828,14 @@ static char *ADD_S(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ADDIU_32_(uint64 instruction, img_address m_pc)
+static char *ADDIU_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_15_to_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt, rs, u);
@@ -1842,12 +1851,12 @@ static char *ADDIU_32_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ADDIU_48_(uint64 instruction, img_address m_pc)
+static char *ADDIU_48_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("ADDIU %s, %s", rt, s);
@@ -1863,12 +1872,12 @@ static char *ADDIU_48_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ADDIU_GP48_(uint64 instruction, img_address m_pc)
+static char *ADDIU_GP48_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, s);
@@ -1884,12 +1893,12 @@ static char *ADDIU_GP48_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ADDIU_GP_B_(uint64 instruction, img_address m_pc)
+static char *ADDIU_GP_B_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, u);
@@ -1905,12 +1914,12 @@ static char *ADDIU_GP_B_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ADDIU_GP_W_(uint64 instruction, img_address m_pc)
+static char *ADDIU_GP_W_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt, 28, u);
@@ -1926,14 +1935,14 @@ static char *ADDIU_GP_W_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ADDIU_NEG_(uint64 instruction, img_address m_pc)
+static char *ADDIU_NEG_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *u = IMMEDIATE_I(neg_copy(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt, rs, u);
@@ -1949,12 +1958,12 @@ static char *ADDIU_NEG_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ADDIU_R1_SP_(uint64 instruction, img_address m_pc)
+static char *ADDIU_R1_SP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 u_value = extract_u_5_4_3_2_1_0__s2(instruction);
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ADDIU %s, $%d, %s", rt3, 29, u);
@@ -1970,14 +1979,14 @@ static char *ADDIU_R1_SP_(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *ADDIU_R2_(uint64 instruction, img_address m_pc)
+static char *ADDIU_R2_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_2_1_0__s2(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ADDIU %s, %s, %s", rt3, rs3, u);
@@ -1992,12 +2001,12 @@ static char *ADDIU_R2_(uint64 instruction, img_address m_pc)
  *     rt -----
  *           s - ---
  */
-static char *ADDIU_RS5_(uint64 instruction, img_address m_pc)
+static char *ADDIU_RS5_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     int64 s_value = extract_s__se3_4_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("ADDIU %s, %s", rt, s);
@@ -2014,13 +2023,13 @@ static char *ADDIU_RS5_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDIUPC_32_(uint64 instruction, img_address m_pc)
+static char *ADDIUPC_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("ADDIUPC %s, %s", rt, s);
 }
@@ -2036,13 +2045,13 @@ static char *ADDIUPC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDIUPC_48_(uint64 instruction, img_address m_pc)
+static char *ADDIUPC_48_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, info->m_pc);
 
     return img_format("ADDIUPC %s, %s", rt, s);
 }
@@ -2058,15 +2067,15 @@ static char *ADDIUPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDQ_PH(uint64 instruction, img_address m_pc)
+static char *ADDQ_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDQ.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2083,15 +2092,15 @@ static char *ADDQ_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDQ_S_PH(uint64 instruction, img_address m_pc)
+static char *ADDQ_S_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDQ_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2107,15 +2116,15 @@ static char *ADDQ_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDQ_S_W(uint64 instruction, img_address m_pc)
+static char *ADDQ_S_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDQ_S.W %s, %s, %s", rd, rs, rt);
 }
@@ -2132,15 +2141,15 @@ static char *ADDQ_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDQH_PH(uint64 instruction, img_address m_pc)
+static char *ADDQH_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDQH.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2157,15 +2166,15 @@ static char *ADDQH_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDQH_R_PH(uint64 instruction, img_address m_pc)
+static char *ADDQH_R_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDQH_R.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2182,15 +2191,15 @@ static char *ADDQH_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDQH_R_W(uint64 instruction, img_address m_pc)
+static char *ADDQH_R_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDQH_R.W %s, %s, %s", rd, rs, rt);
 }
@@ -2207,15 +2216,15 @@ static char *ADDQH_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDQH_W(uint64 instruction, img_address m_pc)
+static char *ADDQH_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDQH.W %s, %s, %s", rd, rs, rt);
 }
@@ -2231,15 +2240,15 @@ static char *ADDQH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDSC(uint64 instruction, img_address m_pc)
+static char *ADDSC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDSC %s, %s, %s", rd, rs, rt);
 }
@@ -2254,15 +2263,15 @@ static char *ADDSC(uint64 instruction, img_address m_pc)
  *       rs3 ---
  *          rd3 ---
  */
-static char *ADDU_16_(uint64 instruction, img_address m_pc)
+static char *ADDU_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 rd3_value = extract_rd3_3_2_1(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    const char *rd3 = GPR(decode_gpr_gpr3(rd3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
+    const char *rd3 = GPR(decode_gpr_gpr3(rd3_value, info), info);
 
     return img_format("ADDU %s, %s, %s", rd3, rs3, rt3);
 }
@@ -2278,15 +2287,15 @@ static char *ADDU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDU_32_(uint64 instruction, img_address m_pc)
+static char *ADDU_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDU %s, %s, %s", rd, rs, rt);
 }
@@ -2302,13 +2311,13 @@ static char *ADDU_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDU_4X4_(uint64 instruction, img_address m_pc)
+static char *ADDU_4X4_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
 
-    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
-    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value));
+    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
+    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
 
     return img_format("ADDU %s, %s", rs4, rt4);
 }
@@ -2324,15 +2333,15 @@ static char *ADDU_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDU_PH(uint64 instruction, img_address m_pc)
+static char *ADDU_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDU.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2348,15 +2357,15 @@ static char *ADDU_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDU_QB(uint64 instruction, img_address m_pc)
+static char *ADDU_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDU.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2373,15 +2382,15 @@ static char *ADDU_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDU_S_PH(uint64 instruction, img_address m_pc)
+static char *ADDU_S_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDU_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -2397,15 +2406,15 @@ static char *ADDU_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDU_S_QB(uint64 instruction, img_address m_pc)
+static char *ADDU_S_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDU_S.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2422,15 +2431,15 @@ static char *ADDU_S_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDUH_QB(uint64 instruction, img_address m_pc)
+static char *ADDUH_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDUH.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2447,15 +2456,15 @@ static char *ADDUH_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDUH_R_QB(uint64 instruction, img_address m_pc)
+static char *ADDUH_R_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDUH_R.QB %s, %s, %s", rd, rs, rt);
 }
@@ -2470,15 +2479,15 @@ static char *ADDUH_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ADDWC(uint64 instruction, img_address m_pc)
+static char *ADDWC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ADDWC %s, %s, %s", rd, rs, rt);
 }
@@ -2494,13 +2503,13 @@ static char *ADDWC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ALUIPC(uint64 instruction, img_address m_pc)
+static char *ALUIPC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
 }
@@ -2515,13 +2524,13 @@ static char *ALUIPC(uint64 instruction, img_address m_pc)
  *       rs3 ---
  *           eu ----
  */
-static char *AND_16_(uint64 instruction, img_address m_pc)
+static char *AND_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
 
     return img_format("AND %s, %s", rs3, rt3);
 }
@@ -2537,15 +2546,15 @@ static char *AND_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *AND_32_(uint64 instruction, img_address m_pc)
+static char *AND_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("AND %s, %s, %s", rd, rs, rt);
 }
@@ -2560,14 +2569,14 @@ static char *AND_32_(uint64 instruction, img_address m_pc)
  *       rs3 ---
  *           eu ----
  */
-static char *ANDI_16_(uint64 instruction, img_address m_pc)
+static char *ANDI_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 eu_value = extract_eu_3_2_1_0(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
     g_autofree char *eu = IMMEDIATE_UI(encode_eu_from_u_andi16(eu_value));
 
     return img_format("ANDI %s, %s, %s", rt3, rs3, eu);
@@ -2584,14 +2593,14 @@ static char *ANDI_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ANDI_32_(uint64 instruction, img_address m_pc)
+static char *ANDI_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ANDI %s, %s, %s", rt, rs, u);
@@ -2608,14 +2617,14 @@ static char *ANDI_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *APPEND(uint64 instruction, img_address m_pc)
+static char *APPEND(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("APPEND %s, %s, %s", rt, rs, sa);
@@ -2632,7 +2641,7 @@ static char *APPEND(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ASET(uint64 instruction, img_address m_pc)
+static char *ASET(uint64 instruction, struct Dis_info *info)
 {
     uint64 bit_value = extract_bit_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -2640,7 +2649,7 @@ static char *ASET(uint64 instruction, img_address m_pc)
 
     g_autofree char *bit = IMMEDIATE_UI(copy_ui(bit_value));
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("ASET %s, %s(%s)", bit, s, rs);
 }
@@ -2656,11 +2665,11 @@ static char *ASET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BALC_16_(uint64 instruction, img_address m_pc)
+static char *BALC_16_(uint64 instruction, struct Dis_info *info)
 {
     int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
 
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, info->m_pc);
 
     return img_format("BALC %s", s);
 }
@@ -2676,11 +2685,11 @@ static char *BALC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BALC_32_(uint64 instruction, img_address m_pc)
+static char *BALC_32_(uint64 instruction, struct Dis_info *info)
 {
     int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
 
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BALC %s", s);
 }
@@ -2696,13 +2705,13 @@ static char *BALC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BALRSC(uint64 instruction, img_address m_pc)
+static char *BALRSC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("BALRSC %s, %s", rt, rs);
 }
@@ -2718,15 +2727,15 @@ static char *BALRSC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BBEQZC(uint64 instruction, img_address m_pc)
+static char *BBEQZC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *bit = IMMEDIATE_UI(copy_ui(bit_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BBEQZC %s, %s, %s", rt, bit, s);
 }
@@ -2742,15 +2751,15 @@ static char *BBEQZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BBNEZC(uint64 instruction, img_address m_pc)
+static char *BBNEZC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 bit_value = extract_bit_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *bit = IMMEDIATE_UI(copy_ui(bit_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BBNEZC %s, %s, %s", rt, bit, s);
 }
@@ -2766,11 +2775,11 @@ static char *BBNEZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BC_16_(uint64 instruction, img_address m_pc)
+static char *BC_16_(uint64 instruction, struct Dis_info *info)
 {
     int64 s_value = extract_s__se10_0_9_8_7_6_5_4_3_2_1_s1(instruction);
 
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, info->m_pc);
 
     return img_format("BC %s", s);
 }
@@ -2786,11 +2795,11 @@ static char *BC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BC_32_(uint64 instruction, img_address m_pc)
+static char *BC_32_(uint64 instruction, struct Dis_info *info)
 {
     int64 s_value = extract_s__se25_0_24_to_1_s1(instruction);
 
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BC %s", s);
 }
@@ -2806,13 +2815,13 @@ static char *BC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BC1EQZC(uint64 instruction, img_address m_pc)
+static char *BC1EQZC(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *ft = FPR(copy_ui(ft_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BC1EQZC %s, %s", ft, s);
 }
@@ -2828,13 +2837,13 @@ static char *BC1EQZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BC1NEZC(uint64 instruction, img_address m_pc)
+static char *BC1NEZC(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *ft = FPR(copy_ui(ft_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BC1NEZC %s, %s", ft, s);
 }
@@ -2850,13 +2859,13 @@ static char *BC1NEZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BC2EQZC(uint64 instruction, img_address m_pc)
+static char *BC2EQZC(uint64 instruction, struct Dis_info *info)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
     g_autofree char *ct = CPR(copy_ui(ct_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BC2EQZC %s, %s", ct, s);
 }
@@ -2872,13 +2881,13 @@ static char *BC2EQZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BC2NEZC(uint64 instruction, img_address m_pc)
+static char *BC2NEZC(uint64 instruction, struct Dis_info *info)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
     g_autofree char *ct = CPR(copy_ui(ct_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BC2NEZC %s, %s", ct, s);
 }
@@ -2894,15 +2903,17 @@ static char *BC2NEZC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BEQC_16_(uint64 instruction, img_address m_pc)
+static char *BEQC_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_3_2_1_0__s1(instruction);
 
-    const char *rs3 = GPR(encode_rs3_and_check_rs3_lt_rt3(rs3_value));
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
+    const char *rs3 = GPR(encode_rs3_and_check_rs3_lt_rt3(rs3_value, info),
+                          info);
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
+    g_autofree char *u = ADDRESS(
+        encode_u_from_address(u_value), 2, info->m_pc);
 
     return img_format("BEQC %s, %s, %s", rs3, rt3, u);
 }
@@ -2918,15 +2929,15 @@ static char *BEQC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BEQC_32_(uint64 instruction, img_address m_pc)
+static char *BEQC_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BEQC %s, %s, %s", rs, rt, s);
 }
@@ -2942,15 +2953,15 @@ static char *BEQC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BEQIC(uint64 instruction, img_address m_pc)
+static char *BEQIC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BEQIC %s, %s, %s", rt, u, s);
 }
@@ -2966,13 +2977,13 @@ static char *BEQIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BEQZC_16_(uint64 instruction, img_address m_pc)
+static char *BEQZC_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, info->m_pc);
 
     return img_format("BEQZC %s, %s", rt3, s);
 }
@@ -2988,15 +2999,15 @@ static char *BEQZC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BGEC(uint64 instruction, img_address m_pc)
+static char *BGEC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BGEC %s, %s, %s", rs, rt, s);
 }
@@ -3012,15 +3023,15 @@ static char *BGEC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BGEIC(uint64 instruction, img_address m_pc)
+static char *BGEIC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BGEIC %s, %s, %s", rt, u, s);
 }
@@ -3036,15 +3047,15 @@ static char *BGEIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BGEIUC(uint64 instruction, img_address m_pc)
+static char *BGEIUC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BGEIUC %s, %s, %s", rt, u, s);
 }
@@ -3060,15 +3071,15 @@ static char *BGEIUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BGEUC(uint64 instruction, img_address m_pc)
+static char *BGEUC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BGEUC %s, %s, %s", rs, rt, s);
 }
@@ -3084,15 +3095,15 @@ static char *BGEUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BLTC(uint64 instruction, img_address m_pc)
+static char *BLTC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BLTC %s, %s, %s", rs, rt, s);
 }
@@ -3108,15 +3119,15 @@ static char *BLTC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BLTIC(uint64 instruction, img_address m_pc)
+static char *BLTIC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BLTIC %s, %s, %s", rt, u, s);
 }
@@ -3132,15 +3143,15 @@ static char *BLTIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BLTIUC(uint64 instruction, img_address m_pc)
+static char *BLTIUC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BLTIUC %s, %s, %s", rt, u, s);
 }
@@ -3156,15 +3167,15 @@ static char *BLTIUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BLTUC(uint64 instruction, img_address m_pc)
+static char *BLTUC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BLTUC %s, %s, %s", rs, rt, s);
 }
@@ -3180,15 +3191,16 @@ static char *BLTUC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BNEC_16_(uint64 instruction, img_address m_pc)
+static char *BNEC_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_3_2_1_0__s1(instruction);
 
-    const char *rs3 = GPR(encode_rs3_and_check_rs3_ge_rt3(rs3_value));
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *u = ADDRESS(encode_u_from_address(u_value), 2, m_pc);
+    const char *rs3 = GPR(encode_rs3_and_check_rs3_ge_rt3(rs3_value, info),
+                          info);
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
+    g_autofree char *u = ADDRESS(encode_u_from_address(u_value), 2, info->m_pc);
 
     return img_format("BNEC %s, %s, %s", rs3, rt3, u);
 }
@@ -3204,15 +3216,15 @@ static char *BNEC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BNEC_32_(uint64 instruction, img_address m_pc)
+static char *BNEC_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BNEC %s, %s, %s", rs, rt, s);
 }
@@ -3228,15 +3240,15 @@ static char *BNEC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BNEIC(uint64 instruction, img_address m_pc)
+static char *BNEIC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_16_15_14_13_12_11(instruction);
     int64 s_value = extract_s__se11_0_10_9_8_7_6_5_4_3_2_1_0_s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BNEIC %s, %s, %s", rt, u, s);
 }
@@ -3252,13 +3264,13 @@ static char *BNEIC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BNEZC_16_(uint64 instruction, img_address m_pc)
+static char *BNEZC_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     int64 s_value = extract_s__se7_0_6_5_4_3_2_1_s1(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, m_pc);
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 2, info->m_pc);
 
     return img_format("BNEZC %s, %s", rt3, s);
 }
@@ -3274,11 +3286,11 @@ static char *BNEZC_16_(uint64 instruction, img_address m_pc)
  *            s[13:1] -------------
  *                           s[14] -
  */
-static char *BPOSGE32C(uint64 instruction, img_address m_pc)
+static char *BPOSGE32C(uint64 instruction, struct Dis_info *info)
 {
     int64 s_value = extract_s__se14_0_13_to_1_s1(instruction);
 
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("BPOSGE32C %s", s);
 }
@@ -3294,7 +3306,7 @@ static char *BPOSGE32C(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BREAK_16_(uint64 instruction, img_address m_pc)
+static char *BREAK_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
@@ -3314,7 +3326,7 @@ static char *BREAK_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BREAK_32_(uint64 instruction, img_address m_pc)
+static char *BREAK_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
@@ -3334,11 +3346,11 @@ static char *BREAK_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *BRSC(uint64 instruction, img_address m_pc)
+static char *BRSC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("BRSC %s", rs);
 }
@@ -3354,7 +3366,7 @@ static char *BRSC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CACHE(uint64 instruction, img_address m_pc)
+static char *CACHE(uint64 instruction, struct Dis_info *info)
 {
     uint64 op_value = extract_op_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3362,7 +3374,7 @@ static char *CACHE(uint64 instruction, img_address m_pc)
 
     g_autofree char *op = IMMEDIATE_UI(copy_ui(op_value));
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("CACHE %s, %s(%s)", op, s, rs);
 }
@@ -3378,7 +3390,7 @@ static char *CACHE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CACHEE(uint64 instruction, img_address m_pc)
+static char *CACHEE(uint64 instruction, struct Dis_info *info)
 {
     uint64 op_value = extract_op_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -3386,7 +3398,7 @@ static char *CACHEE(uint64 instruction, img_address m_pc)
 
     g_autofree char *op = IMMEDIATE_UI(copy_ui(op_value));
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("CACHEE %s, %s(%s)", op, s, rs);
 }
@@ -3402,13 +3414,13 @@ static char *CACHEE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CEIL_L_D(uint64 instruction, img_address m_pc)
+static char *CEIL_L_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CEIL.L.D %s, %s", ft, fs);
 }
@@ -3424,13 +3436,13 @@ static char *CEIL_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CEIL_L_S(uint64 instruction, img_address m_pc)
+static char *CEIL_L_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CEIL.L.S %s, %s", ft, fs);
 }
@@ -3446,13 +3458,13 @@ static char *CEIL_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CEIL_W_D(uint64 instruction, img_address m_pc)
+static char *CEIL_W_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CEIL.W.D %s, %s", ft, fs);
 }
@@ -3468,13 +3480,13 @@ static char *CEIL_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CEIL_W_S(uint64 instruction, img_address m_pc)
+static char *CEIL_W_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CEIL.W.S %s, %s", ft, fs);
 }
@@ -3490,12 +3502,12 @@ static char *CEIL_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CFC1(uint64 instruction, img_address m_pc)
+static char *CFC1(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("CFC1 %s, %s", rt, cs);
@@ -3512,12 +3524,12 @@ static char *CFC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CFC2(uint64 instruction, img_address m_pc)
+static char *CFC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("CFC2 %s, %s", rt, cs);
@@ -3534,13 +3546,13 @@ static char *CFC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CLASS_D(uint64 instruction, img_address m_pc)
+static char *CLASS_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CLASS.D %s, %s", ft, fs);
 }
@@ -3556,13 +3568,13 @@ static char *CLASS_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CLASS_S(uint64 instruction, img_address m_pc)
+static char *CLASS_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CLASS.S %s, %s", ft, fs);
 }
@@ -3578,13 +3590,13 @@ static char *CLASS_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CLO(uint64 instruction, img_address m_pc)
+static char *CLO(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("CLO %s, %s", rt, rs);
 }
@@ -3600,13 +3612,13 @@ static char *CLO(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CLZ(uint64 instruction, img_address m_pc)
+static char *CLZ(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("CLZ %s, %s", rt, rs);
 }
@@ -3622,15 +3634,15 @@ static char *CLZ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_AF_D(uint64 instruction, img_address m_pc)
+static char *CMP_AF_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.AF.D %s, %s, %s", fd, fs, ft);
 }
@@ -3646,15 +3658,15 @@ static char *CMP_AF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_AF_S(uint64 instruction, img_address m_pc)
+static char *CMP_AF_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.AF.S %s, %s, %s", fd, fs, ft);
 }
@@ -3670,15 +3682,15 @@ static char *CMP_AF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_EQ_D(uint64 instruction, img_address m_pc)
+static char *CMP_EQ_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.EQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -3693,13 +3705,13 @@ static char *CMP_EQ_D(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *CMP_EQ_PH(uint64 instruction, img_address m_pc)
+static char *CMP_EQ_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMP.EQ.PH %s, %s", rs, rt);
 }
@@ -3715,15 +3727,15 @@ static char *CMP_EQ_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_EQ_S(uint64 instruction, img_address m_pc)
+static char *CMP_EQ_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.EQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -3739,15 +3751,15 @@ static char *CMP_EQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_LE_D(uint64 instruction, img_address m_pc)
+static char *CMP_LE_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.LE.D %s, %s, %s", fd, fs, ft);
 }
@@ -3762,13 +3774,13 @@ static char *CMP_LE_D(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *CMP_LE_PH(uint64 instruction, img_address m_pc)
+static char *CMP_LE_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMP.LE.PH %s, %s", rs, rt);
 }
@@ -3784,15 +3796,15 @@ static char *CMP_LE_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_LE_S(uint64 instruction, img_address m_pc)
+static char *CMP_LE_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.LE.S %s, %s, %s", fd, fs, ft);
 }
@@ -3808,15 +3820,15 @@ static char *CMP_LE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_LT_D(uint64 instruction, img_address m_pc)
+static char *CMP_LT_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.LT.D %s, %s, %s", fd, fs, ft);
 }
@@ -3831,13 +3843,13 @@ static char *CMP_LT_D(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *CMP_LT_PH(uint64 instruction, img_address m_pc)
+static char *CMP_LT_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMP.LT.PH %s, %s", rs, rt);
 }
@@ -3853,15 +3865,15 @@ static char *CMP_LT_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_LT_S(uint64 instruction, img_address m_pc)
+static char *CMP_LT_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.LT.S %s, %s, %s", fd, fs, ft);
 }
@@ -3877,15 +3889,15 @@ static char *CMP_LT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_NE_D(uint64 instruction, img_address m_pc)
+static char *CMP_NE_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.NE.D %s, %s, %s", fd, fs, ft);
 }
@@ -3901,15 +3913,15 @@ static char *CMP_NE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_NE_S(uint64 instruction, img_address m_pc)
+static char *CMP_NE_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.NE.S %s, %s, %s", fd, fs, ft);
 }
@@ -3925,15 +3937,15 @@ static char *CMP_NE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_OR_D(uint64 instruction, img_address m_pc)
+static char *CMP_OR_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.OR.D %s, %s, %s", fd, fs, ft);
 }
@@ -3949,15 +3961,15 @@ static char *CMP_OR_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_OR_S(uint64 instruction, img_address m_pc)
+static char *CMP_OR_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.OR.S %s, %s, %s", fd, fs, ft);
 }
@@ -3973,15 +3985,15 @@ static char *CMP_OR_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SAF_D(uint64 instruction, img_address m_pc)
+static char *CMP_SAF_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SAF.D %s, %s, %s", fd, fs, ft);
 }
@@ -3997,15 +4009,15 @@ static char *CMP_SAF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SAF_S(uint64 instruction, img_address m_pc)
+static char *CMP_SAF_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SAF.S %s, %s, %s", fd, fs, ft);
 }
@@ -4021,15 +4033,15 @@ static char *CMP_SAF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SEQ_D(uint64 instruction, img_address m_pc)
+static char *CMP_SEQ_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SEQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -4045,15 +4057,15 @@ static char *CMP_SEQ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SEQ_S(uint64 instruction, img_address m_pc)
+static char *CMP_SEQ_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SEQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -4069,15 +4081,15 @@ static char *CMP_SEQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SLE_D(uint64 instruction, img_address m_pc)
+static char *CMP_SLE_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SLE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4093,15 +4105,15 @@ static char *CMP_SLE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SLE_S(uint64 instruction, img_address m_pc)
+static char *CMP_SLE_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SLE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4117,15 +4129,15 @@ static char *CMP_SLE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SLT_D(uint64 instruction, img_address m_pc)
+static char *CMP_SLT_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SLT.D %s, %s, %s", fd, fs, ft);
 }
@@ -4141,15 +4153,15 @@ static char *CMP_SLT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SLT_S(uint64 instruction, img_address m_pc)
+static char *CMP_SLT_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SLT.S %s, %s, %s", fd, fs, ft);
 }
@@ -4165,15 +4177,15 @@ static char *CMP_SLT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SNE_D(uint64 instruction, img_address m_pc)
+static char *CMP_SNE_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SNE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4189,15 +4201,15 @@ static char *CMP_SNE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SNE_S(uint64 instruction, img_address m_pc)
+static char *CMP_SNE_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SNE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4213,15 +4225,15 @@ static char *CMP_SNE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SOR_D(uint64 instruction, img_address m_pc)
+static char *CMP_SOR_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SOR.D %s, %s, %s", fd, fs, ft);
 }
@@ -4237,15 +4249,15 @@ static char *CMP_SOR_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SOR_S(uint64 instruction, img_address m_pc)
+static char *CMP_SOR_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SOR.S %s, %s, %s", fd, fs, ft);
 }
@@ -4261,15 +4273,15 @@ static char *CMP_SOR_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SUEQ_D(uint64 instruction, img_address m_pc)
+static char *CMP_SUEQ_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SUEQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -4285,15 +4297,15 @@ static char *CMP_SUEQ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SUEQ_S(uint64 instruction, img_address m_pc)
+static char *CMP_SUEQ_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SUEQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -4309,15 +4321,15 @@ static char *CMP_SUEQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SULE_D(uint64 instruction, img_address m_pc)
+static char *CMP_SULE_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SULE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4333,15 +4345,15 @@ static char *CMP_SULE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SULE_S(uint64 instruction, img_address m_pc)
+static char *CMP_SULE_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SULE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4357,15 +4369,15 @@ static char *CMP_SULE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SULT_D(uint64 instruction, img_address m_pc)
+static char *CMP_SULT_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SULT.D %s, %s, %s", fd, fs, ft);
 }
@@ -4381,15 +4393,15 @@ static char *CMP_SULT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SULT_S(uint64 instruction, img_address m_pc)
+static char *CMP_SULT_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SULT.S %s, %s, %s", fd, fs, ft);
 }
@@ -4405,15 +4417,15 @@ static char *CMP_SULT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SUN_D(uint64 instruction, img_address m_pc)
+static char *CMP_SUN_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SUN.D %s, %s, %s", fd, fs, ft);
 }
@@ -4429,15 +4441,15 @@ static char *CMP_SUN_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SUNE_D(uint64 instruction, img_address m_pc)
+static char *CMP_SUNE_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SUNE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4453,15 +4465,15 @@ static char *CMP_SUNE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SUNE_S(uint64 instruction, img_address m_pc)
+static char *CMP_SUNE_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SUNE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4477,15 +4489,15 @@ static char *CMP_SUNE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_SUN_S(uint64 instruction, img_address m_pc)
+static char *CMP_SUN_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.SUN.S %s, %s, %s", fd, fs, ft);
 }
@@ -4501,15 +4513,15 @@ static char *CMP_SUN_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_UEQ_D(uint64 instruction, img_address m_pc)
+static char *CMP_UEQ_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.UEQ.D %s, %s, %s", fd, fs, ft);
 }
@@ -4525,15 +4537,15 @@ static char *CMP_UEQ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_UEQ_S(uint64 instruction, img_address m_pc)
+static char *CMP_UEQ_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.UEQ.S %s, %s, %s", fd, fs, ft);
 }
@@ -4549,15 +4561,15 @@ static char *CMP_UEQ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_ULE_D(uint64 instruction, img_address m_pc)
+static char *CMP_ULE_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.ULE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4573,15 +4585,15 @@ static char *CMP_ULE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_ULE_S(uint64 instruction, img_address m_pc)
+static char *CMP_ULE_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.ULE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4597,15 +4609,15 @@ static char *CMP_ULE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_ULT_D(uint64 instruction, img_address m_pc)
+static char *CMP_ULT_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.ULT.D %s, %s, %s", fd, fs, ft);
 }
@@ -4621,15 +4633,15 @@ static char *CMP_ULT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_ULT_S(uint64 instruction, img_address m_pc)
+static char *CMP_ULT_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.ULT.S %s, %s, %s", fd, fs, ft);
 }
@@ -4645,15 +4657,15 @@ static char *CMP_ULT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_UN_D(uint64 instruction, img_address m_pc)
+static char *CMP_UN_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.UN.D %s, %s, %s", fd, fs, ft);
 }
@@ -4669,15 +4681,15 @@ static char *CMP_UN_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_UNE_D(uint64 instruction, img_address m_pc)
+static char *CMP_UNE_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.UNE.D %s, %s, %s", fd, fs, ft);
 }
@@ -4693,15 +4705,15 @@ static char *CMP_UNE_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_UNE_S(uint64 instruction, img_address m_pc)
+static char *CMP_UNE_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.UNE.S %s, %s, %s", fd, fs, ft);
 }
@@ -4717,15 +4729,15 @@ static char *CMP_UNE_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMP_UN_S(uint64 instruction, img_address m_pc)
+static char *CMP_UN_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("CMP.UN.S %s, %s, %s", fd, fs, ft);
 }
@@ -4742,15 +4754,15 @@ static char *CMP_UN_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMPGDU_EQ_QB(uint64 instruction, img_address m_pc)
+static char *CMPGDU_EQ_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMPGDU.EQ.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4767,15 +4779,15 @@ static char *CMPGDU_EQ_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMPGDU_LE_QB(uint64 instruction, img_address m_pc)
+static char *CMPGDU_LE_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMPGDU.LE.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4792,15 +4804,15 @@ static char *CMPGDU_LE_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMPGDU_LT_QB(uint64 instruction, img_address m_pc)
+static char *CMPGDU_LT_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMPGDU.LT.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4817,15 +4829,15 @@ static char *CMPGDU_LT_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMPGU_EQ_QB(uint64 instruction, img_address m_pc)
+static char *CMPGU_EQ_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMPGU.EQ.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4842,15 +4854,15 @@ static char *CMPGU_EQ_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMPGU_LE_QB(uint64 instruction, img_address m_pc)
+static char *CMPGU_LE_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMPGU.LE.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4867,15 +4879,15 @@ static char *CMPGU_LE_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CMPGU_LT_QB(uint64 instruction, img_address m_pc)
+static char *CMPGU_LT_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMPGU.LT.QB %s, %s, %s", rd, rs, rt);
 }
@@ -4891,13 +4903,13 @@ static char *CMPGU_LT_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *CMPU_EQ_QB(uint64 instruction, img_address m_pc)
+static char *CMPU_EQ_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMPU.EQ.QB %s, %s", rs, rt);
 }
@@ -4913,13 +4925,13 @@ static char *CMPU_EQ_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *CMPU_LE_QB(uint64 instruction, img_address m_pc)
+static char *CMPU_LE_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMPU.LE.QB %s, %s", rs, rt);
 }
@@ -4935,13 +4947,13 @@ static char *CMPU_LE_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *CMPU_LT_QB(uint64 instruction, img_address m_pc)
+static char *CMPU_LT_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("CMPU.LT.QB %s, %s", rs, rt);
 }
@@ -4957,7 +4969,7 @@ static char *CMPU_LT_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *COP2_1(uint64 instruction, img_address m_pc)
+static char *COP2_1(uint64 instruction, struct Dis_info *info)
 {
     uint64 cofun_value = extract_cofun_25_24_23(instruction);
 
@@ -4977,12 +4989,12 @@ static char *COP2_1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CTC1(uint64 instruction, img_address m_pc)
+static char *CTC1(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("CTC1 %s, %s", rt, cs);
@@ -4999,12 +5011,12 @@ static char *CTC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CTC2(uint64 instruction, img_address m_pc)
+static char *CTC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("CTC2 %s, %s", rt, cs);
@@ -5021,13 +5033,13 @@ static char *CTC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_D_L(uint64 instruction, img_address m_pc)
+static char *CVT_D_L(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.D.L %s, %s", ft, fs);
 }
@@ -5043,13 +5055,13 @@ static char *CVT_D_L(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_D_S(uint64 instruction, img_address m_pc)
+static char *CVT_D_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.D.S %s, %s", ft, fs);
 }
@@ -5065,13 +5077,13 @@ static char *CVT_D_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_D_W(uint64 instruction, img_address m_pc)
+static char *CVT_D_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.D.W %s, %s", ft, fs);
 }
@@ -5087,13 +5099,13 @@ static char *CVT_D_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_L_D(uint64 instruction, img_address m_pc)
+static char *CVT_L_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.L.D %s, %s", ft, fs);
 }
@@ -5109,13 +5121,13 @@ static char *CVT_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_L_S(uint64 instruction, img_address m_pc)
+static char *CVT_L_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.L.S %s, %s", ft, fs);
 }
@@ -5131,13 +5143,13 @@ static char *CVT_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_S_D(uint64 instruction, img_address m_pc)
+static char *CVT_S_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.S.D %s, %s", ft, fs);
 }
@@ -5153,13 +5165,13 @@ static char *CVT_S_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_S_L(uint64 instruction, img_address m_pc)
+static char *CVT_S_L(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.S.L %s, %s", ft, fs);
 }
@@ -5175,13 +5187,13 @@ static char *CVT_S_L(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_S_PL(uint64 instruction, img_address m_pc)
+static char *CVT_S_PL(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.S.PL %s, %s", ft, fs);
 }
@@ -5197,13 +5209,13 @@ static char *CVT_S_PL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_S_PU(uint64 instruction, img_address m_pc)
+static char *CVT_S_PU(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.S.PU %s, %s", ft, fs);
 }
@@ -5219,13 +5231,13 @@ static char *CVT_S_PU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_S_W(uint64 instruction, img_address m_pc)
+static char *CVT_S_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.S.W %s, %s", ft, fs);
 }
@@ -5241,13 +5253,13 @@ static char *CVT_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_W_D(uint64 instruction, img_address m_pc)
+static char *CVT_W_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.W.D %s, %s", ft, fs);
 }
@@ -5263,13 +5275,13 @@ static char *CVT_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *CVT_W_S(uint64 instruction, img_address m_pc)
+static char *CVT_W_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("CVT.W.S %s, %s", ft, fs);
 }
@@ -5285,12 +5297,12 @@ static char *CVT_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DADDIU_48_(uint64 instruction, img_address m_pc)
+static char *DADDIU_48_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("DADDIU %s, %s", rt, s);
@@ -5307,14 +5319,14 @@ static char *DADDIU_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DADDIU_NEG_(uint64 instruction, img_address m_pc)
+static char *DADDIU_NEG_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *u = IMMEDIATE_I(neg_copy(u_value));
 
     return img_format("DADDIU %s, %s, %s", rt, rs, u);
@@ -5331,14 +5343,14 @@ static char *DADDIU_NEG_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DADDIU_U12_(uint64 instruction, img_address m_pc)
+static char *DADDIU_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("DADDIU %s, %s, %s", rt, rs, u);
@@ -5355,15 +5367,15 @@ static char *DADDIU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DADD(uint64 instruction, img_address m_pc)
+static char *DADD(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DADD %s, %s, %s", rd, rs, rt);
 }
@@ -5379,15 +5391,15 @@ static char *DADD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DADDU(uint64 instruction, img_address m_pc)
+static char *DADDU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DADDU %s, %s, %s", rd, rs, rt);
 }
@@ -5403,13 +5415,13 @@ static char *DADDU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DCLO(uint64 instruction, img_address m_pc)
+static char *DCLO(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("DCLO %s, %s", rt, rs);
 }
@@ -5425,13 +5437,13 @@ static char *DCLO(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DCLZ(uint64 instruction, img_address m_pc)
+static char *DCLZ(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("DCLZ %s, %s", rt, rs);
 }
@@ -5447,15 +5459,15 @@ static char *DCLZ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DDIV(uint64 instruction, img_address m_pc)
+static char *DDIV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DDIV %s, %s, %s", rd, rs, rt);
 }
@@ -5471,15 +5483,15 @@ static char *DDIV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DDIVU(uint64 instruction, img_address m_pc)
+static char *DDIVU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DDIVU %s, %s, %s", rd, rs, rt);
 }
@@ -5495,7 +5507,7 @@ static char *DDIVU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DERET(uint64 instruction, img_address m_pc)
+static char *DERET(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -5513,15 +5525,15 @@ static char *DERET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DEXTM(uint64 instruction, img_address m_pc)
+static char *DEXTM(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *lsb = IMMEDIATE_UI(copy_ui(lsb_value));
     g_autofree char *msbd = IMMEDIATE_UI(encode_msbd_from_size(msbd_value));
 
@@ -5539,15 +5551,15 @@ static char *DEXTM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DEXT(uint64 instruction, img_address m_pc)
+static char *DEXT(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *lsb = IMMEDIATE_UI(copy_ui(lsb_value));
     g_autofree char *msbd = IMMEDIATE_UI(encode_msbd_from_size(msbd_value));
 
@@ -5565,15 +5577,15 @@ static char *DEXT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DEXTU(uint64 instruction, img_address m_pc)
+static char *DEXTU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *lsb = IMMEDIATE_UI(copy_ui(lsb_value));
     g_autofree char *msbd = IMMEDIATE_UI(encode_msbd_from_size(msbd_value));
 
@@ -5591,15 +5603,15 @@ static char *DEXTU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DINSM(uint64 instruction, img_address m_pc)
+static char *DINSM(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *pos = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
         lsb_value));
     g_autofree char *size = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
@@ -5621,15 +5633,15 @@ static char *DINSM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DINS(uint64 instruction, img_address m_pc)
+static char *DINS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *pos = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
         lsb_value));
     g_autofree char *size = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
@@ -5651,15 +5663,15 @@ static char *DINS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DINSU(uint64 instruction, img_address m_pc)
+static char *DINSU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *pos = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
         lsb_value));
     g_autofree char *size = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
@@ -5681,11 +5693,11 @@ static char *DINSU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DI(uint64 instruction, img_address m_pc)
+static char *DI(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DI %s", rt);
 }
@@ -5701,15 +5713,15 @@ static char *DI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DIV(uint64 instruction, img_address m_pc)
+static char *DIV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DIV %s, %s, %s", rd, rs, rt);
 }
@@ -5725,15 +5737,15 @@ static char *DIV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DIV_D(uint64 instruction, img_address m_pc)
+static char *DIV_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("DIV.D %s, %s, %s", fd, fs, ft);
 }
@@ -5749,15 +5761,15 @@ static char *DIV_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DIV_S(uint64 instruction, img_address m_pc)
+static char *DIV_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("DIV.S %s, %s, %s", fd, fs, ft);
 }
@@ -5773,15 +5785,15 @@ static char *DIV_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DIVU(uint64 instruction, img_address m_pc)
+static char *DIVU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DIVU %s, %s, %s", rd, rs, rt);
 }
@@ -5797,16 +5809,16 @@ static char *DIVU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DLSA(uint64 instruction, img_address m_pc)
+static char *DLSA(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 u2_value = extract_u2_10_9(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u2 = IMMEDIATE_UI(copy_ui(u2_value));
 
     return img_format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
@@ -5823,12 +5835,12 @@ static char *DLSA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DLUI_48_(uint64 instruction, img_address m_pc)
+static char *DLUI_48_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     uint64 u_value = extract_u_31_to_0__s32(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("DLUI %s, %s", rt, u);
@@ -5845,13 +5857,13 @@ static char *DLUI_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMFC0(uint64 instruction, img_address m_pc)
+static char *DMFC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -5869,13 +5881,13 @@ static char *DMFC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMFC1(uint64 instruction, img_address m_pc)
+static char *DMFC1(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("DMFC1 %s, %s", rt, fs);
 }
@@ -5891,12 +5903,12 @@ static char *DMFC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMFC2(uint64 instruction, img_address m_pc)
+static char *DMFC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("DMFC2 %s, %s", rt, cs);
@@ -5913,13 +5925,13 @@ static char *DMFC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMFGC0(uint64 instruction, img_address m_pc)
+static char *DMFGC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -5937,15 +5949,15 @@ static char *DMFGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMOD(uint64 instruction, img_address m_pc)
+static char *DMOD(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DMOD %s, %s, %s", rd, rs, rt);
 }
@@ -5961,15 +5973,15 @@ static char *DMOD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMODU(uint64 instruction, img_address m_pc)
+static char *DMODU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DMODU %s, %s, %s", rd, rs, rt);
 }
@@ -5985,13 +5997,13 @@ static char *DMODU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMTC0(uint64 instruction, img_address m_pc)
+static char *DMTC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -6009,13 +6021,13 @@ static char *DMTC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMTC1(uint64 instruction, img_address m_pc)
+static char *DMTC1(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("DMTC1 %s, %s", rt, fs);
 }
@@ -6031,12 +6043,12 @@ static char *DMTC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMTC2(uint64 instruction, img_address m_pc)
+static char *DMTC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("DMTC2 %s, %s", rt, cs);
@@ -6053,13 +6065,13 @@ static char *DMTC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMTGC0(uint64 instruction, img_address m_pc)
+static char *DMTGC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -6077,11 +6089,11 @@ static char *DMTGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMT(uint64 instruction, img_address m_pc)
+static char *DMT(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DMT %s", rt);
 }
@@ -6097,15 +6109,15 @@ static char *DMT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMUH(uint64 instruction, img_address m_pc)
+static char *DMUH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DMUH %s, %s, %s", rd, rs, rt);
 }
@@ -6121,15 +6133,15 @@ static char *DMUH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMUHU(uint64 instruction, img_address m_pc)
+static char *DMUHU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DMUHU %s, %s, %s", rd, rs, rt);
 }
@@ -6145,15 +6157,15 @@ static char *DMUHU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMUL(uint64 instruction, img_address m_pc)
+static char *DMUL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DMUL %s, %s, %s", rd, rs, rt);
 }
@@ -6169,15 +6181,15 @@ static char *DMUL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DMULU(uint64 instruction, img_address m_pc)
+static char *DMULU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DMULU %s, %s, %s", rd, rs, rt);
 }
@@ -6194,15 +6206,15 @@ static char *DMULU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *DPA_W_PH(uint64 instruction, img_address m_pc)
+static char *DPA_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6218,15 +6230,15 @@ static char *DPA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPAQ_SA_L_W(uint64 instruction, img_address m_pc)
+static char *DPAQ_SA_L_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPAQ_SA.L.W %s, %s, %s", ac, rs, rt);
 }
@@ -6242,15 +6254,15 @@ static char *DPAQ_SA_L_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPAQ_S_W_PH(uint64 instruction, img_address m_pc)
+static char *DPAQ_S_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPAQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6266,15 +6278,15 @@ static char *DPAQ_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPAQX_SA_W_PH(uint64 instruction, img_address m_pc)
+static char *DPAQX_SA_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPAQX_SA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6290,15 +6302,15 @@ static char *DPAQX_SA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPAQX_S_W_PH(uint64 instruction, img_address m_pc)
+static char *DPAQX_S_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPAQX_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6314,15 +6326,15 @@ static char *DPAQX_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPAU_H_QBL(uint64 instruction, img_address m_pc)
+static char *DPAU_H_QBL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPAU.H.QBL %s, %s, %s", ac, rs, rt);
 }
@@ -6338,15 +6350,15 @@ static char *DPAU_H_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPAU_H_QBR(uint64 instruction, img_address m_pc)
+static char *DPAU_H_QBR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPAU.H.QBR %s, %s, %s", ac, rs, rt);
 }
@@ -6362,15 +6374,15 @@ static char *DPAU_H_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPAX_W_PH(uint64 instruction, img_address m_pc)
+static char *DPAX_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPAX.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6386,15 +6398,15 @@ static char *DPAX_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPS_W_PH(uint64 instruction, img_address m_pc)
+static char *DPS_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPS.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6410,15 +6422,15 @@ static char *DPS_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPSQ_SA_L_W(uint64 instruction, img_address m_pc)
+static char *DPSQ_SA_L_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPSQ_SA.L.W %s, %s, %s", ac, rs, rt);
 }
@@ -6434,15 +6446,15 @@ static char *DPSQ_SA_L_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPSQ_S_W_PH(uint64 instruction, img_address m_pc)
+static char *DPSQ_S_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPSQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6458,15 +6470,15 @@ static char *DPSQ_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPSQX_SA_W_PH(uint64 instruction, img_address m_pc)
+static char *DPSQX_SA_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPSQX_SA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6482,15 +6494,15 @@ static char *DPSQX_SA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPSQX_S_W_PH(uint64 instruction, img_address m_pc)
+static char *DPSQX_S_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPSQX_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6506,15 +6518,15 @@ static char *DPSQX_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPSU_H_QBL(uint64 instruction, img_address m_pc)
+static char *DPSU_H_QBL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPSU.H.QBL %s, %s, %s", ac, rs, rt);
 }
@@ -6530,15 +6542,15 @@ static char *DPSU_H_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPSU_H_QBR(uint64 instruction, img_address m_pc)
+static char *DPSU_H_QBR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPSU.H.QBR %s, %s, %s", ac, rs, rt);
 }
@@ -6554,15 +6566,15 @@ static char *DPSU_H_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DPSX_W_PH(uint64 instruction, img_address m_pc)
+static char *DPSX_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DPSX.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -6578,14 +6590,14 @@ static char *DPSX_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DROTR(uint64 instruction, img_address m_pc)
+static char *DROTR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DROTR %s, %s, %s", rt, rs, shift);
@@ -6602,14 +6614,14 @@ static char *DROTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static char *DROTR32(uint64 instruction, img_address m_pc)
+static char *DROTR32(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DROTR32 %s, %s, %s", rt, rs, shift);
@@ -6626,15 +6638,15 @@ static char *DROTR32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DROTRV(uint64 instruction, img_address m_pc)
+static char *DROTRV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DROTRV %s, %s, %s", rd, rs, rt);
 }
@@ -6650,15 +6662,15 @@ static char *DROTRV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DROTX(uint64 instruction, img_address m_pc)
+static char *DROTX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shiftx_value = extract_shiftx_11_10_9_8_7_6(instruction);
     uint64 shift_value = extract_shift_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
     g_autofree char *shiftx = IMMEDIATE_UI(copy_ui(shiftx_value));
 
@@ -6676,14 +6688,14 @@ static char *DROTX(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static char *DSLL(uint64 instruction, img_address m_pc)
+static char *DSLL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSLL %s, %s, %s", rt, rs, shift);
@@ -6700,14 +6712,14 @@ static char *DSLL(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static char *DSLL32(uint64 instruction, img_address m_pc)
+static char *DSLL32(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSLL32 %s, %s, %s", rt, rs, shift);
@@ -6724,15 +6736,15 @@ static char *DSLL32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DSLLV(uint64 instruction, img_address m_pc)
+static char *DSLLV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DSLLV %s, %s, %s", rd, rs, rt);
 }
@@ -6748,14 +6760,14 @@ static char *DSLLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static char *DSRA(uint64 instruction, img_address m_pc)
+static char *DSRA(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSRA %s, %s, %s", rt, rs, shift);
@@ -6772,14 +6784,14 @@ static char *DSRA(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static char *DSRA32(uint64 instruction, img_address m_pc)
+static char *DSRA32(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSRA32 %s, %s, %s", rt, rs, shift);
@@ -6796,15 +6808,15 @@ static char *DSRA32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DSRAV(uint64 instruction, img_address m_pc)
+static char *DSRAV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DSRAV %s, %s, %s", rd, rs, rt);
 }
@@ -6820,14 +6832,14 @@ static char *DSRAV(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static char *DSRL(uint64 instruction, img_address m_pc)
+static char *DSRL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSRL %s, %s, %s", rt, rs, shift);
@@ -6844,14 +6856,14 @@ static char *DSRL(uint64 instruction, img_address m_pc)
  *          rs -----
  *                       shift -----
  */
-static char *DSRL32(uint64 instruction, img_address m_pc)
+static char *DSRL32(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("DSRL32 %s, %s, %s", rt, rs, shift);
@@ -6868,15 +6880,15 @@ static char *DSRL32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DSRLV(uint64 instruction, img_address m_pc)
+static char *DSRLV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DSRLV %s, %s, %s", rd, rs, rt);
 }
@@ -6892,15 +6904,15 @@ static char *DSRLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DSUB(uint64 instruction, img_address m_pc)
+static char *DSUB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DSUB %s, %s, %s", rd, rs, rt);
 }
@@ -6916,15 +6928,15 @@ static char *DSUB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DSUBU(uint64 instruction, img_address m_pc)
+static char *DSUBU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DSUBU %s, %s, %s", rd, rs, rt);
 }
@@ -6940,11 +6952,11 @@ static char *DSUBU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DVPE(uint64 instruction, img_address m_pc)
+static char *DVPE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DVPE %s", rt);
 }
@@ -6960,11 +6972,11 @@ static char *DVPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *DVP(uint64 instruction, img_address m_pc)
+static char *DVP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("DVP %s", rt);
 }
@@ -6980,7 +6992,7 @@ static char *DVP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EHB(uint64 instruction, img_address m_pc)
+static char *EHB(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -6998,11 +7010,11 @@ static char *EHB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EI(uint64 instruction, img_address m_pc)
+static char *EI(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("EI %s", rt);
 }
@@ -7018,11 +7030,11 @@ static char *EI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EMT(uint64 instruction, img_address m_pc)
+static char *EMT(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("EMT %s", rt);
 }
@@ -7038,7 +7050,7 @@ static char *EMT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ERET(uint64 instruction, img_address m_pc)
+static char *ERET(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -7056,7 +7068,7 @@ static char *ERET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ERETNC(uint64 instruction, img_address m_pc)
+static char *ERETNC(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -7074,11 +7086,11 @@ static char *ERETNC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EVP(uint64 instruction, img_address m_pc)
+static char *EVP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("EVP %s", rt);
 }
@@ -7094,11 +7106,11 @@ static char *EVP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EVPE(uint64 instruction, img_address m_pc)
+static char *EVPE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("EVPE %s", rt);
 }
@@ -7114,15 +7126,15 @@ static char *EVPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EXT(uint64 instruction, img_address m_pc)
+static char *EXT(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *lsb = IMMEDIATE_UI(copy_ui(lsb_value));
     g_autofree char *msbd = IMMEDIATE_UI(encode_msbd_from_size(msbd_value));
 
@@ -7140,16 +7152,16 @@ static char *EXT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EXTD(uint64 instruction, img_address m_pc)
+static char *EXTD(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
@@ -7166,16 +7178,16 @@ static char *EXTD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EXTD32(uint64 instruction, img_address m_pc)
+static char *EXTD32(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
@@ -7192,14 +7204,14 @@ static char *EXTD32(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EXTPDP(uint64 instruction, img_address m_pc)
+static char *EXTPDP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 size_value = extract_size_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
     g_autofree char *size = IMMEDIATE_UI(copy_ui(size_value));
 
     return img_format("EXTPDP %s, %s, %s", rt, ac, size);
@@ -7216,15 +7228,15 @@ static char *EXTPDP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EXTPDPV(uint64 instruction, img_address m_pc)
+static char *EXTPDPV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("EXTPDPV %s, %s, %s", rt, ac, rs);
 }
@@ -7240,14 +7252,14 @@ static char *EXTPDPV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EXTP(uint64 instruction, img_address m_pc)
+static char *EXTP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 size_value = extract_size_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
     g_autofree char *size = IMMEDIATE_UI(copy_ui(size_value));
 
     return img_format("EXTP %s, %s, %s", rt, ac, size);
@@ -7264,15 +7276,15 @@ static char *EXTP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *EXTPV(uint64 instruction, img_address m_pc)
+static char *EXTPV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("EXTPV %s, %s, %s", rt, ac, rs);
 }
@@ -7289,14 +7301,14 @@ static char *EXTPV(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-static char *EXTR_RS_W(uint64 instruction, img_address m_pc)
+static char *EXTR_RS_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
@@ -7314,14 +7326,14 @@ static char *EXTR_RS_W(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-static char *EXTR_R_W(uint64 instruction, img_address m_pc)
+static char *EXTR_R_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTR_R.W %s, %s, %s", rt, ac, shift);
@@ -7339,14 +7351,14 @@ static char *EXTR_R_W(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-static char *EXTR_S_H(uint64 instruction, img_address m_pc)
+static char *EXTR_S_H(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTR_S.H %s, %s, %s", rt, ac, shift);
@@ -7364,14 +7376,14 @@ static char *EXTR_S_H(uint64 instruction, img_address m_pc)
  *       shift -----
  *               ac --
  */
-static char *EXTR_W(uint64 instruction, img_address m_pc)
+static char *EXTR_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 shift_value = extract_shift_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTR.W %s, %s, %s", rt, ac, shift);
@@ -7389,15 +7401,15 @@ static char *EXTR_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *EXTRV_RS_W(uint64 instruction, img_address m_pc)
+static char *EXTRV_RS_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("EXTRV_RS.W %s, %s, %s", rt, ac, rs);
 }
@@ -7414,15 +7426,15 @@ static char *EXTRV_RS_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *EXTRV_R_W(uint64 instruction, img_address m_pc)
+static char *EXTRV_R_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("EXTRV_R.W %s, %s, %s", rt, ac, rs);
 }
@@ -7439,15 +7451,15 @@ static char *EXTRV_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *EXTRV_S_H(uint64 instruction, img_address m_pc)
+static char *EXTRV_S_H(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("EXTRV_S.H %s, %s, %s", rt, ac, rs);
 }
@@ -7464,15 +7476,15 @@ static char *EXTRV_S_H(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *EXTRV_W(uint64 instruction, img_address m_pc)
+static char *EXTRV_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("EXTRV.W %s, %s, %s", rt, ac, rs);
 }
@@ -7489,16 +7501,16 @@ static char *EXTRV_W(uint64 instruction, img_address m_pc)
  *               rd -----
  *                 shift -----
  */
-static char *EXTW(uint64 instruction, img_address m_pc)
+static char *EXTW(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 shift_value = extract_shift_10_9_8_7_6(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
@@ -7515,13 +7527,13 @@ static char *EXTW(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *FLOOR_L_D(uint64 instruction, img_address m_pc)
+static char *FLOOR_L_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("FLOOR.L.D %s, %s", ft, fs);
 }
@@ -7537,13 +7549,13 @@ static char *FLOOR_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *FLOOR_L_S(uint64 instruction, img_address m_pc)
+static char *FLOOR_L_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("FLOOR.L.S %s, %s", ft, fs);
 }
@@ -7559,13 +7571,13 @@ static char *FLOOR_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *FLOOR_W_D(uint64 instruction, img_address m_pc)
+static char *FLOOR_W_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("FLOOR.W.D %s, %s", ft, fs);
 }
@@ -7581,13 +7593,13 @@ static char *FLOOR_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *FLOOR_W_S(uint64 instruction, img_address m_pc)
+static char *FLOOR_W_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("FLOOR.W.S %s, %s", ft, fs);
 }
@@ -7603,15 +7615,15 @@ static char *FLOOR_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *FORK(uint64 instruction, img_address m_pc)
+static char *FORK(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("FORK %s, %s, %s", rd, rs, rt);
 }
@@ -7627,7 +7639,7 @@ static char *FORK(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *HYPCALL(uint64 instruction, img_address m_pc)
+static char *HYPCALL(uint64 instruction, struct Dis_info *info)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
@@ -7647,7 +7659,7 @@ static char *HYPCALL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *HYPCALL_16_(uint64 instruction, img_address m_pc)
+static char *HYPCALL_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
@@ -7667,15 +7679,15 @@ static char *HYPCALL_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *INS(uint64 instruction, img_address m_pc)
+static char *INS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 msbd_value = extract_msbt_10_9_8_7_6(instruction);
     uint64 lsb_value = extract_lsb_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *pos = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
         lsb_value));
     g_autofree char *size = IMMEDIATE_UI(encode_lsb_from_pos_and_size(
@@ -7696,13 +7708,13 @@ static char *INS(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *INSV(uint64 instruction, img_address m_pc)
+static char *INSV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("INSV %s, %s", rt, rs);
 }
@@ -7718,7 +7730,7 @@ static char *INSV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *IRET(uint64 instruction, img_address m_pc)
+static char *IRET(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -7736,11 +7748,11 @@ static char *IRET(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *JALRC_16_(uint64 instruction, img_address m_pc)
+static char *JALRC_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("JALRC $%d, %s", 31, rt);
 }
@@ -7756,13 +7768,13 @@ static char *JALRC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *JALRC_32_(uint64 instruction, img_address m_pc)
+static char *JALRC_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("JALRC %s, %s", rt, rs);
 }
@@ -7778,13 +7790,13 @@ static char *JALRC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *JALRC_HB(uint64 instruction, img_address m_pc)
+static char *JALRC_HB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("JALRC.HB %s, %s", rt, rs);
 }
@@ -7800,11 +7812,11 @@ static char *JALRC_HB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *JRC(uint64 instruction, img_address m_pc)
+static char *JRC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("JRC %s", rt);
 }
@@ -7820,15 +7832,15 @@ static char *JRC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LB_16_(uint64 instruction, img_address m_pc)
+static char *LB_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_1_0(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
 
     return img_format("LB %s, %s(%s)", rt3, u, rs3);
 }
@@ -7844,12 +7856,12 @@ static char *LB_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LB_GP_(uint64 instruction, img_address m_pc)
+static char *LB_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LB %s, %s($%d)", rt, u, 28);
@@ -7866,15 +7878,15 @@ static char *LB_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LB_S9_(uint64 instruction, img_address m_pc)
+static char *LB_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LB %s, %s(%s)", rt, s, rs);
 }
@@ -7890,15 +7902,15 @@ static char *LB_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LB_U12_(uint64 instruction, img_address m_pc)
+static char *LB_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LB %s, %s(%s)", rt, u, rs);
 }
@@ -7914,15 +7926,15 @@ static char *LB_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LBE(uint64 instruction, img_address m_pc)
+static char *LBE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LBE %s, %s(%s)", rt, s, rs);
 }
@@ -7938,15 +7950,15 @@ static char *LBE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LBU_16_(uint64 instruction, img_address m_pc)
+static char *LBU_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_1_0(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
 
     return img_format("LBU %s, %s(%s)", rt3, u, rs3);
 }
@@ -7962,12 +7974,12 @@ static char *LBU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LBU_GP_(uint64 instruction, img_address m_pc)
+static char *LBU_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LBU %s, %s($%d)", rt, u, 28);
@@ -7984,15 +7996,15 @@ static char *LBU_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LBU_S9_(uint64 instruction, img_address m_pc)
+static char *LBU_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LBU %s, %s(%s)", rt, s, rs);
 }
@@ -8008,15 +8020,15 @@ static char *LBU_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LBU_U12_(uint64 instruction, img_address m_pc)
+static char *LBU_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LBU %s, %s(%s)", rt, u, rs);
 }
@@ -8032,15 +8044,15 @@ static char *LBU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LBUE(uint64 instruction, img_address m_pc)
+static char *LBUE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LBUE %s, %s(%s)", rt, s, rs);
 }
@@ -8056,15 +8068,15 @@ static char *LBUE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LBUX(uint64 instruction, img_address m_pc)
+static char *LBUX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LBUX %s, %s(%s)", rd, rs, rt);
 }
@@ -8080,15 +8092,15 @@ static char *LBUX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LBX(uint64 instruction, img_address m_pc)
+static char *LBX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LBX %s, %s(%s)", rd, rs, rt);
 }
@@ -8104,12 +8116,12 @@ static char *LBX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LD_GP_(uint64 instruction, img_address m_pc)
+static char *LD_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_3__s3(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LD %s, %s($%d)", rt, u, 28);
@@ -8126,15 +8138,15 @@ static char *LD_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LD_S9_(uint64 instruction, img_address m_pc)
+static char *LD_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LD %s, %s(%s)", rt, s, rs);
 }
@@ -8150,15 +8162,15 @@ static char *LD_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LD_U12_(uint64 instruction, img_address m_pc)
+static char *LD_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LD %s, %s(%s)", rt, u, rs);
 }
@@ -8174,12 +8186,12 @@ static char *LD_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LDC1_GP_(uint64 instruction, img_address m_pc)
+static char *LDC1_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LDC1 %s, %s($%d)", ft, u, 28);
@@ -8196,15 +8208,15 @@ static char *LDC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LDC1_S9_(uint64 instruction, img_address m_pc)
+static char *LDC1_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LDC1 %s, %s(%s)", ft, s, rs);
 }
@@ -8220,15 +8232,15 @@ static char *LDC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LDC1_U12_(uint64 instruction, img_address m_pc)
+static char *LDC1_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LDC1 %s, %s(%s)", ft, u, rs);
 }
@@ -8244,15 +8256,15 @@ static char *LDC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LDC1XS(uint64 instruction, img_address m_pc)
+static char *LDC1XS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LDC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -8268,15 +8280,15 @@ static char *LDC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LDC1X(uint64 instruction, img_address m_pc)
+static char *LDC1X(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LDC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -8292,7 +8304,7 @@ static char *LDC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LDC2(uint64 instruction, img_address m_pc)
+static char *LDC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -8300,7 +8312,7 @@ static char *LDC2(uint64 instruction, img_address m_pc)
 
     g_autofree char *ct = CPR(copy_ui(ct_value));
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LDC2 %s, %s(%s)", ct, s, rs);
 }
@@ -8316,16 +8328,16 @@ static char *LDC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LDM(uint64 instruction, img_address m_pc)
+static char *LDM(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
         count3_value));
 
@@ -8343,13 +8355,13 @@ static char *LDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LDPC_48_(uint64 instruction, img_address m_pc)
+static char *LDPC_48_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, info->m_pc);
 
     return img_format("LDPC %s, %s", rt, s);
 }
@@ -8365,15 +8377,15 @@ static char *LDPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LDX(uint64 instruction, img_address m_pc)
+static char *LDX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LDX %s, %s(%s)", rd, rs, rt);
 }
@@ -8389,15 +8401,15 @@ static char *LDX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LDXS(uint64 instruction, img_address m_pc)
+static char *LDXS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LDXS %s, %s(%s)", rd, rs, rt);
 }
@@ -8413,15 +8425,15 @@ static char *LDXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LH_16_(uint64 instruction, img_address m_pc)
+static char *LH_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_2_1__s1(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
 
     return img_format("LH %s, %s(%s)", rt3, u, rs3);
 }
@@ -8437,12 +8449,12 @@ static char *LH_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LH_GP_(uint64 instruction, img_address m_pc)
+static char *LH_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LH %s, %s($%d)", rt, u, 28);
@@ -8459,15 +8471,15 @@ static char *LH_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LH_S9_(uint64 instruction, img_address m_pc)
+static char *LH_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LH %s, %s(%s)", rt, s, rs);
 }
@@ -8483,15 +8495,15 @@ static char *LH_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LH_U12_(uint64 instruction, img_address m_pc)
+static char *LH_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LH %s, %s(%s)", rt, u, rs);
 }
@@ -8507,15 +8519,15 @@ static char *LH_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LHE(uint64 instruction, img_address m_pc)
+static char *LHE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LHE %s, %s(%s)", rt, s, rs);
 }
@@ -8531,15 +8543,15 @@ static char *LHE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LHU_16_(uint64 instruction, img_address m_pc)
+static char *LHU_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_2_1__s1(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
 
     return img_format("LHU %s, %s(%s)", rt3, u, rs3);
 }
@@ -8555,12 +8567,12 @@ static char *LHU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LHU_GP_(uint64 instruction, img_address m_pc)
+static char *LHU_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LHU %s, %s($%d)", rt, u, 28);
@@ -8577,15 +8589,15 @@ static char *LHU_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LHU_S9_(uint64 instruction, img_address m_pc)
+static char *LHU_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LHU %s, %s(%s)", rt, s, rs);
 }
@@ -8601,15 +8613,15 @@ static char *LHU_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LHU_U12_(uint64 instruction, img_address m_pc)
+static char *LHU_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LHU %s, %s(%s)", rt, u, rs);
 }
@@ -8625,15 +8637,15 @@ static char *LHU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LHUE(uint64 instruction, img_address m_pc)
+static char *LHUE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LHUE %s, %s(%s)", rt, s, rs);
 }
@@ -8649,15 +8661,15 @@ static char *LHUE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LHUX(uint64 instruction, img_address m_pc)
+static char *LHUX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LHUX %s, %s(%s)", rd, rs, rt);
 }
@@ -8673,15 +8685,15 @@ static char *LHUX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LHUXS(uint64 instruction, img_address m_pc)
+static char *LHUXS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LHUXS %s, %s(%s)", rd, rs, rt);
 }
@@ -8697,15 +8709,15 @@ static char *LHUXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LHXS(uint64 instruction, img_address m_pc)
+static char *LHXS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LHXS %s, %s(%s)", rd, rs, rt);
 }
@@ -8721,15 +8733,15 @@ static char *LHXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LHX(uint64 instruction, img_address m_pc)
+static char *LHX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LHX %s, %s(%s)", rd, rs, rt);
 }
@@ -8745,12 +8757,12 @@ static char *LHX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LI_16_(uint64 instruction, img_address m_pc)
+static char *LI_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 eu_value = extract_eu_6_5_4_3_2_1_0(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
     g_autofree char *eu = IMMEDIATE_I(encode_eu_from_s_li16(eu_value));
 
     return img_format("LI %s, %s", rt3, eu);
@@ -8767,12 +8779,12 @@ static char *LI_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LI_48_(uint64 instruction, img_address m_pc)
+static char *LI_48_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("LI %s, %s", rt, s);
@@ -8789,15 +8801,15 @@ static char *LI_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LL(uint64 instruction, img_address m_pc)
+static char *LL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LL %s, %s(%s)", rt, s, rs);
 }
@@ -8813,15 +8825,15 @@ static char *LL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LLD(uint64 instruction, img_address m_pc)
+static char *LLD(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LLD %s, %s(%s)", rt, s, rs);
 }
@@ -8837,15 +8849,15 @@ static char *LLD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LLDP(uint64 instruction, img_address m_pc)
+static char *LLDP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ru = GPR(copy_ui(ru_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ru = GPR(copy_ui(ru_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LLDP %s, %s, (%s)", rt, ru, rs);
 }
@@ -8861,15 +8873,15 @@ static char *LLDP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LLE(uint64 instruction, img_address m_pc)
+static char *LLE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LLE %s, %s(%s)", rt, s, rs);
 }
@@ -8885,15 +8897,15 @@ static char *LLE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LLWP(uint64 instruction, img_address m_pc)
+static char *LLWP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ru = GPR(copy_ui(ru_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ru = GPR(copy_ui(ru_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LLWP %s, %s, (%s)", rt, ru, rs);
 }
@@ -8909,15 +8921,15 @@ static char *LLWP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LLWPE(uint64 instruction, img_address m_pc)
+static char *LLWPE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ru = GPR(copy_ui(ru_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ru = GPR(copy_ui(ru_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LLWPE %s, %s, (%s)", rt, ru, rs);
 }
@@ -8933,16 +8945,16 @@ static char *LLWPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LSA(uint64 instruction, img_address m_pc)
+static char *LSA(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
     uint64 u2_value = extract_u2_10_9(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u2 = IMMEDIATE_UI(copy_ui(u2_value));
 
     return img_format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
@@ -8959,12 +8971,12 @@ static char *LSA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LUI(uint64 instruction, img_address m_pc)
+static char *LUI(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se31_0_11_to_2_20_to_12_s12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("LUI %s, %%hi(%s)", rt, s);
@@ -8981,15 +8993,15 @@ static char *LUI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LW_16_(uint64 instruction, img_address m_pc)
+static char *LW_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_3_2_1_0__s2(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
 
     return img_format("LW %s, %s(%s)", rt3, u, rs3);
 }
@@ -9005,15 +9017,15 @@ static char *LW_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LW_4X4_(uint64 instruction, img_address m_pc)
+static char *LW_4X4_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
     uint64 u_value = extract_u_3_8__s2(instruction);
 
-    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value));
+    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
+    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
 
     return img_format("LW %s, %s(%s)", rt4, u, rs4);
 }
@@ -9029,12 +9041,12 @@ static char *LW_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LW_GP_(uint64 instruction, img_address m_pc)
+static char *LW_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LW %s, %s($%d)", rt, u, 28);
@@ -9051,12 +9063,12 @@ static char *LW_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LW_GP16_(uint64 instruction, img_address m_pc)
+static char *LW_GP16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LW %s, %s($%d)", rt3, u, 28);
@@ -9073,15 +9085,15 @@ static char *LW_GP16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LW_S9_(uint64 instruction, img_address m_pc)
+static char *LW_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LW %s, %s(%s)", rt, s, rs);
 }
@@ -9097,12 +9109,12 @@ static char *LW_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LW_SP_(uint64 instruction, img_address m_pc)
+static char *LW_SP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LW %s, %s($%d)", rt, u, 29);
@@ -9119,15 +9131,15 @@ static char *LW_SP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LW_U12_(uint64 instruction, img_address m_pc)
+static char *LW_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LW %s, %s(%s)", rt, u, rs);
 }
@@ -9143,12 +9155,12 @@ static char *LW_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWC1_GP_(uint64 instruction, img_address m_pc)
+static char *LWC1_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LWC1 %s, %s($%d)", ft, u, 28);
@@ -9165,15 +9177,15 @@ static char *LWC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWC1_S9_(uint64 instruction, img_address m_pc)
+static char *LWC1_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LWC1 %s, %s(%s)", ft, s, rs);
 }
@@ -9189,15 +9201,15 @@ static char *LWC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWC1_U12_(uint64 instruction, img_address m_pc)
+static char *LWC1_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LWC1 %s, %s(%s)", ft, u, rs);
 }
@@ -9213,15 +9225,15 @@ static char *LWC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWC1X(uint64 instruction, img_address m_pc)
+static char *LWC1X(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LWC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -9237,15 +9249,15 @@ static char *LWC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWC1XS(uint64 instruction, img_address m_pc)
+static char *LWC1XS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LWC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -9261,7 +9273,7 @@ static char *LWC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWC2(uint64 instruction, img_address m_pc)
+static char *LWC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 ct_value = extract_ct_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -9269,7 +9281,7 @@ static char *LWC2(uint64 instruction, img_address m_pc)
 
     g_autofree char *ct = CPR(copy_ui(ct_value));
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LWC2 %s, %s(%s)", ct, s, rs);
 }
@@ -9285,15 +9297,15 @@ static char *LWC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWE(uint64 instruction, img_address m_pc)
+static char *LWE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LWE %s, %s(%s)", rt, s, rs);
 }
@@ -9309,16 +9321,16 @@ static char *LWE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWM(uint64 instruction, img_address m_pc)
+static char *LWM(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
         count3_value));
 
@@ -9336,13 +9348,13 @@ static char *LWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWPC_48_(uint64 instruction, img_address m_pc)
+static char *LWPC_48_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, info->m_pc);
 
     return img_format("LWPC %s, %s", rt, s);
 }
@@ -9358,12 +9370,12 @@ static char *LWPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWU_GP_(uint64 instruction, img_address m_pc)
+static char *LWU_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("LWU %s, %s($%d)", rt, u, 28);
@@ -9380,15 +9392,15 @@ static char *LWU_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWU_S9_(uint64 instruction, img_address m_pc)
+static char *LWU_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LWU %s, %s(%s)", rt, s, rs);
 }
@@ -9404,15 +9416,15 @@ static char *LWU_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWU_U12_(uint64 instruction, img_address m_pc)
+static char *LWU_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("LWU %s, %s(%s)", rt, u, rs);
 }
@@ -9428,15 +9440,15 @@ static char *LWU_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWUX(uint64 instruction, img_address m_pc)
+static char *LWUX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LWUX %s, %s(%s)", rd, rs, rt);
 }
@@ -9452,15 +9464,15 @@ static char *LWUX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWUXS(uint64 instruction, img_address m_pc)
+static char *LWUXS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LWUXS %s, %s(%s)", rd, rs, rt);
 }
@@ -9476,15 +9488,15 @@ static char *LWUXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWX(uint64 instruction, img_address m_pc)
+static char *LWX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LWX %s, %s(%s)", rd, rs, rt);
 }
@@ -9500,15 +9512,15 @@ static char *LWX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWXS_16_(uint64 instruction, img_address m_pc)
+static char *LWXS_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 rd3_value = extract_rd3_3_2_1(instruction);
 
-    const char *rd3 = GPR(decode_gpr_gpr3(rd3_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    g_autofree char *rt3 = IMMEDIATE_UI(decode_gpr_gpr3(rt3_value));
+    const char *rd3 = GPR(decode_gpr_gpr3(rd3_value, info), info);
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
+    g_autofree char *rt3 = IMMEDIATE_UI(decode_gpr_gpr3(rt3_value, info));
 
     return img_format("LWXS %s, %s(%s)", rd3, rs3, rt3);
 }
@@ -9524,15 +9536,15 @@ static char *LWXS_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *LWXS_32_(uint64 instruction, img_address m_pc)
+static char *LWXS_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("LWXS %s, %s(%s)", rd, rs, rt);
 }
@@ -9549,15 +9561,15 @@ static char *LWXS_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MADD_DSP_(uint64 instruction, img_address m_pc)
+static char *MADD_DSP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MADD %s, %s, %s", ac, rs, rt);
 }
@@ -9573,15 +9585,15 @@ static char *MADD_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MADDF_D(uint64 instruction, img_address m_pc)
+static char *MADDF_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MADDF.D %s, %s, %s", fd, fs, ft);
 }
@@ -9597,15 +9609,15 @@ static char *MADDF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MADDF_S(uint64 instruction, img_address m_pc)
+static char *MADDF_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MADDF.S %s, %s, %s", fd, fs, ft);
 }
@@ -9622,15 +9634,15 @@ static char *MADDF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MADDU_DSP_(uint64 instruction, img_address m_pc)
+static char *MADDU_DSP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MADDU %s, %s, %s", ac, rs, rt);
 }
@@ -9647,15 +9659,15 @@ static char *MADDU_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MAQ_S_W_PHL(uint64 instruction, img_address m_pc)
+static char *MAQ_S_W_PHL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MAQ_S.W.PHL %s, %s, %s", ac, rs, rt);
 }
@@ -9672,15 +9684,15 @@ static char *MAQ_S_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MAQ_S_W_PHR(uint64 instruction, img_address m_pc)
+static char *MAQ_S_W_PHR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MAQ_S.W.PHR %s, %s, %s", ac, rs, rt);
 }
@@ -9697,15 +9709,15 @@ static char *MAQ_S_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MAQ_SA_W_PHL(uint64 instruction, img_address m_pc)
+static char *MAQ_SA_W_PHL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MAQ_SA.W.PHL %s, %s, %s", ac, rs, rt);
 }
@@ -9722,15 +9734,15 @@ static char *MAQ_SA_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MAQ_SA_W_PHR(uint64 instruction, img_address m_pc)
+static char *MAQ_SA_W_PHR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MAQ_SA.W.PHR %s, %s, %s", ac, rs, rt);
 }
@@ -9746,15 +9758,15 @@ static char *MAQ_SA_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MAX_D(uint64 instruction, img_address m_pc)
+static char *MAX_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MAX.D %s, %s, %s", fd, fs, ft);
 }
@@ -9770,15 +9782,15 @@ static char *MAX_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MAX_S(uint64 instruction, img_address m_pc)
+static char *MAX_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MAX.S %s, %s, %s", fd, fs, ft);
 }
@@ -9794,15 +9806,15 @@ static char *MAX_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MAXA_D(uint64 instruction, img_address m_pc)
+static char *MAXA_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MAXA.D %s, %s, %s", fd, fs, ft);
 }
@@ -9818,15 +9830,15 @@ static char *MAXA_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MAXA_S(uint64 instruction, img_address m_pc)
+static char *MAXA_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MAXA.S %s, %s, %s", fd, fs, ft);
 }
@@ -9842,13 +9854,13 @@ static char *MAXA_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MFC0(uint64 instruction, img_address m_pc)
+static char *MFC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -9866,13 +9878,13 @@ static char *MFC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MFC1(uint64 instruction, img_address m_pc)
+static char *MFC1(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("MFC1 %s, %s", rt, fs);
 }
@@ -9888,12 +9900,12 @@ static char *MFC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MFC2(uint64 instruction, img_address m_pc)
+static char *MFC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("MFC2 %s, %s", rt, cs);
@@ -9910,13 +9922,13 @@ static char *MFC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MFGC0(uint64 instruction, img_address m_pc)
+static char *MFGC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -9934,13 +9946,13 @@ static char *MFGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MFHC0(uint64 instruction, img_address m_pc)
+static char *MFHC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -9958,13 +9970,13 @@ static char *MFHC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MFHC1(uint64 instruction, img_address m_pc)
+static char *MFHC1(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("MFHC1 %s, %s", rt, fs);
 }
@@ -9980,12 +9992,12 @@ static char *MFHC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MFHC2(uint64 instruction, img_address m_pc)
+static char *MFHC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("MFHC2 %s, %s", rt, cs);
@@ -10002,13 +10014,13 @@ static char *MFHC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MFHGC0(uint64 instruction, img_address m_pc)
+static char *MFHGC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -10025,13 +10037,13 @@ static char *MFHGC0(uint64 instruction, img_address m_pc)
  *     rt -----
  *               ac --
  */
-static char *MFHI_DSP_(uint64 instruction, img_address m_pc)
+static char *MFHI_DSP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
 
     return img_format("MFHI %s, %s", rt, ac);
 }
@@ -10047,14 +10059,14 @@ static char *MFHI_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MFHTR(uint64 instruction, img_address m_pc)
+static char *MFHTR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = IMMEDIATE_UI(copy_ui(c0s_value));
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
@@ -10072,13 +10084,13 @@ static char *MFHTR(uint64 instruction, img_address m_pc)
  *     rt -----
  *               ac --
  */
-static char *MFLO_DSP_(uint64 instruction, img_address m_pc)
+static char *MFLO_DSP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
 
     return img_format("MFLO %s, %s", rt, ac);
 }
@@ -10094,14 +10106,14 @@ static char *MFLO_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MFTR(uint64 instruction, img_address m_pc)
+static char *MFTR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = IMMEDIATE_UI(copy_ui(c0s_value));
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
@@ -10120,15 +10132,15 @@ static char *MFTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MIN_D(uint64 instruction, img_address m_pc)
+static char *MIN_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MIN.D %s, %s, %s", fd, fs, ft);
 }
@@ -10144,15 +10156,15 @@ static char *MIN_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MIN_S(uint64 instruction, img_address m_pc)
+static char *MIN_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MIN.S %s, %s, %s", fd, fs, ft);
 }
@@ -10168,15 +10180,15 @@ static char *MIN_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MINA_D(uint64 instruction, img_address m_pc)
+static char *MINA_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MINA.D %s, %s, %s", fd, fs, ft);
 }
@@ -10192,15 +10204,15 @@ static char *MINA_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MINA_S(uint64 instruction, img_address m_pc)
+static char *MINA_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MINA.S %s, %s, %s", fd, fs, ft);
 }
@@ -10216,15 +10228,15 @@ static char *MINA_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MOD(uint64 instruction, img_address m_pc)
+static char *MOD(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MOD %s, %s, %s", rd, rs, rt);
 }
@@ -10240,15 +10252,15 @@ static char *MOD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MODSUB(uint64 instruction, img_address m_pc)
+static char *MODSUB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MODSUB %s, %s, %s", rd, rs, rt);
 }
@@ -10264,15 +10276,15 @@ static char *MODSUB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MODU(uint64 instruction, img_address m_pc)
+static char *MODU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MODU %s, %s, %s", rd, rs, rt);
 }
@@ -10288,13 +10300,13 @@ static char *MODU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MOV_D(uint64 instruction, img_address m_pc)
+static char *MOV_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("MOV.D %s, %s", ft, fs);
 }
@@ -10310,13 +10322,13 @@ static char *MOV_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MOV_S(uint64 instruction, img_address m_pc)
+static char *MOV_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("MOV.S %s, %s", ft, fs);
 }
@@ -10332,15 +10344,15 @@ static char *MOV_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MOVE_BALC(uint64 instruction, img_address m_pc)
+static char *MOVE_BALC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rtz4_value = extract_rtz4_27_26_25_23_22_21(instruction);
     uint64 rd1_value = extract_rdl_25_24(instruction);
     int64 s_value = extract_s__se21_0_20_to_1_s1(instruction);
 
-    const char *rd1 = GPR(decode_gpr_gpr1(rd1_value));
-    const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, m_pc);
+    const char *rd1 = GPR(decode_gpr_gpr1(rd1_value, info), info);
+    const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value, info), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 4, info->m_pc);
 
     return img_format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
 }
@@ -10356,17 +10368,17 @@ static char *MOVE_BALC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MOVEP(uint64 instruction, img_address m_pc)
+static char *MOVEP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
     uint64 rd2_value = extract_rd2_3_8(instruction);
     uint64 rsz4_value = extract_rsz4_4_2_1_0(instruction);
 
-    const char *rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value));
-    const char *re2 = GPR(decode_gpr_gpr2_reg2(rd2_value));
+    const char *rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value, info), info);
+    const char *re2 = GPR(decode_gpr_gpr2_reg2(rd2_value, info), info);
     /* !!!!!!!!!! - no conversion function */
-    const char *rsz4 = GPR(decode_gpr_gpr4_zero(rsz4_value));
-    const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
+    const char *rsz4 = GPR(decode_gpr_gpr4_zero(rsz4_value, info), info);
+    const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value, info), info);
 
     return img_format("MOVEP %s, %s, %s, %s", rd2, re2, rsz4, rtz4);
     /* hand edited */
@@ -10383,16 +10395,16 @@ static char *MOVEP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MOVEP_REV_(uint64 instruction, img_address m_pc)
+static char *MOVEP_REV_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rd2_value = extract_rd2_3_8(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
 
-    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
-    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value));
-    const char *rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value));
-    const char *rs2 = GPR(decode_gpr_gpr2_reg2(rd2_value));
+    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
+    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
+    const char *rd2 = GPR(decode_gpr_gpr2_reg1(rd2_value, info), info);
+    const char *rs2 = GPR(decode_gpr_gpr2_reg2(rd2_value, info), info);
     /* !!!!!!!!!! - no conversion function */
 
     return img_format("MOVEP %s, %s, %s, %s", rs4, rt4, rd2, rs2);
@@ -10410,13 +10422,13 @@ static char *MOVEP_REV_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MOVE(uint64 instruction, img_address m_pc)
+static char *MOVE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 rs_value = extract_rs_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("MOVE %s, %s", rt, rs);
 }
@@ -10432,15 +10444,15 @@ static char *MOVE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MOVN(uint64 instruction, img_address m_pc)
+static char *MOVN(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MOVN %s, %s, %s", rd, rs, rt);
 }
@@ -10456,15 +10468,15 @@ static char *MOVN(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MOVZ(uint64 instruction, img_address m_pc)
+static char *MOVZ(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MOVZ %s, %s, %s", rd, rs, rt);
 }
@@ -10480,15 +10492,15 @@ static char *MOVZ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *MSUB_DSP_(uint64 instruction, img_address m_pc)
+static char *MSUB_DSP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MSUB %s, %s, %s", ac, rs, rt);
 }
@@ -10504,15 +10516,15 @@ static char *MSUB_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MSUBF_D(uint64 instruction, img_address m_pc)
+static char *MSUBF_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MSUBF.D %s, %s, %s", fd, fs, ft);
 }
@@ -10528,15 +10540,15 @@ static char *MSUBF_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MSUBF_S(uint64 instruction, img_address m_pc)
+static char *MSUBF_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MSUBF.S %s, %s, %s", fd, fs, ft);
 }
@@ -10552,15 +10564,15 @@ static char *MSUBF_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *MSUBU_DSP_(uint64 instruction, img_address m_pc)
+static char *MSUBU_DSP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MSUBU %s, %s, %s", ac, rs, rt);
 }
@@ -10576,13 +10588,13 @@ static char *MSUBU_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MTC0(uint64 instruction, img_address m_pc)
+static char *MTC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -10600,13 +10612,13 @@ static char *MTC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MTC1(uint64 instruction, img_address m_pc)
+static char *MTC1(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("MTC1 %s, %s", rt, fs);
 }
@@ -10622,12 +10634,12 @@ static char *MTC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MTC2(uint64 instruction, img_address m_pc)
+static char *MTC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("MTC2 %s, %s", rt, cs);
@@ -10644,13 +10656,13 @@ static char *MTC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MTGC0(uint64 instruction, img_address m_pc)
+static char *MTGC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -10668,13 +10680,13 @@ static char *MTGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MTHC0(uint64 instruction, img_address m_pc)
+static char *MTHC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -10692,13 +10704,13 @@ static char *MTHC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MTHC1(uint64 instruction, img_address m_pc)
+static char *MTHC1(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("MTHC1 %s, %s", rt, fs);
 }
@@ -10714,12 +10726,12 @@ static char *MTHC1(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MTHC2(uint64 instruction, img_address m_pc)
+static char *MTHC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 cs_value = extract_cs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *cs = CPR(copy_ui(cs_value));
 
     return img_format("MTHC2 %s, %s", rt, cs);
@@ -10736,13 +10748,13 @@ static char *MTHC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MTHGC0(uint64 instruction, img_address m_pc)
+static char *MTHGC0(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = CPR(copy_ui(c0s_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -10759,13 +10771,13 @@ static char *MTHGC0(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *MTHI_DSP_(uint64 instruction, img_address m_pc)
+static char *MTHI_DSP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
 
     return img_format("MTHI %s, %s", rs, ac);
 }
@@ -10780,13 +10792,13 @@ static char *MTHI_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *MTHLIP(uint64 instruction, img_address m_pc)
+static char *MTHLIP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
 
     return img_format("MTHLIP %s, %s", rs, ac);
 }
@@ -10802,14 +10814,14 @@ static char *MTHLIP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MTHTR(uint64 instruction, img_address m_pc)
+static char *MTHTR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = IMMEDIATE_UI(copy_ui(c0s_value));
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
@@ -10827,13 +10839,13 @@ static char *MTHTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *MTLO_DSP_(uint64 instruction, img_address m_pc)
+static char *MTLO_DSP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
 
     return img_format("MTLO %s, %s", rs, ac);
 }
@@ -10849,14 +10861,14 @@ static char *MTLO_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MTTR(uint64 instruction, img_address m_pc)
+static char *MTTR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 c0s_value = extract_c0s_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_15_14_13_12_11(instruction);
     uint64 u_value = extract_u_10(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *c0s = IMMEDIATE_UI(copy_ui(c0s_value));
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
@@ -10875,15 +10887,15 @@ static char *MTTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MUH(uint64 instruction, img_address m_pc)
+static char *MUH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MUH %s, %s, %s", rd, rs, rt);
 }
@@ -10899,15 +10911,15 @@ static char *MUH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MUHU(uint64 instruction, img_address m_pc)
+static char *MUHU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MUHU %s, %s, %s", rd, rs, rt);
 }
@@ -10923,15 +10935,15 @@ static char *MUHU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MUL_32_(uint64 instruction, img_address m_pc)
+static char *MUL_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MUL %s, %s, %s", rd, rs, rt);
 }
@@ -10947,13 +10959,13 @@ static char *MUL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MUL_4X4_(uint64 instruction, img_address m_pc)
+static char *MUL_4X4_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt4_value = extract_rt4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
 
-    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
-    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value));
+    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
+    const char *rt4 = GPR(decode_gpr_gpr4(rt4_value, info), info);
 
     return img_format("MUL %s, %s", rs4, rt4);
 }
@@ -10969,15 +10981,15 @@ static char *MUL_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MUL_D(uint64 instruction, img_address m_pc)
+static char *MUL_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MUL.D %s, %s, %s", fd, fs, ft);
 }
@@ -10994,15 +11006,15 @@ static char *MUL_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MUL_PH(uint64 instruction, img_address m_pc)
+static char *MUL_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MUL.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11019,15 +11031,15 @@ static char *MUL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MUL_S_PH(uint64 instruction, img_address m_pc)
+static char *MUL_S_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MUL_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11043,15 +11055,15 @@ static char *MUL_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MUL_S(uint64 instruction, img_address m_pc)
+static char *MUL_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("MUL.S %s, %s, %s", fd, fs, ft);
 }
@@ -11068,15 +11080,15 @@ static char *MUL_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MULEQ_S_W_PHL(uint64 instruction, img_address m_pc)
+static char *MULEQ_S_W_PHL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULEQ_S.W.PHL %s, %s, %s", rd, rs, rt);
 }
@@ -11093,15 +11105,15 @@ static char *MULEQ_S_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MULEQ_S_W_PHR(uint64 instruction, img_address m_pc)
+static char *MULEQ_S_W_PHR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULEQ_S.W.PHR %s, %s, %s", rd, rs, rt);
 }
@@ -11118,15 +11130,15 @@ static char *MULEQ_S_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MULEU_S_PH_QBL(uint64 instruction, img_address m_pc)
+static char *MULEU_S_PH_QBL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULEU_S.PH.QBL %s, %s, %s", rd, rs, rt);
 }
@@ -11143,15 +11155,15 @@ static char *MULEU_S_PH_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MULEU_S_PH_QBR(uint64 instruction, img_address m_pc)
+static char *MULEU_S_PH_QBR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULEU_S.PH.QBR %s, %s, %s", rd, rs, rt);
 }
@@ -11168,15 +11180,15 @@ static char *MULEU_S_PH_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MULQ_RS_PH(uint64 instruction, img_address m_pc)
+static char *MULQ_RS_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULQ_RS.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11193,15 +11205,15 @@ static char *MULQ_RS_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MULQ_RS_W(uint64 instruction, img_address m_pc)
+static char *MULQ_RS_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULQ_RS.W %s, %s, %s", rd, rs, rt);
 }
@@ -11218,15 +11230,15 @@ static char *MULQ_RS_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MULQ_S_PH(uint64 instruction, img_address m_pc)
+static char *MULQ_S_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULQ_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11243,15 +11255,15 @@ static char *MULQ_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MULQ_S_W(uint64 instruction, img_address m_pc)
+static char *MULQ_S_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULQ_S.W %s, %s, %s", rd, rs, rt);
 }
@@ -11268,15 +11280,15 @@ static char *MULQ_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *MULSA_W_PH(uint64 instruction, img_address m_pc)
+static char *MULSA_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULSA.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -11293,15 +11305,15 @@ static char *MULSA_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *MULSAQ_S_W_PH(uint64 instruction, img_address m_pc)
+static char *MULSAQ_S_W_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULSAQ_S.W.PH %s, %s, %s", ac, rs, rt);
 }
@@ -11317,15 +11329,15 @@ static char *MULSAQ_S_W_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *MULT_DSP_(uint64 instruction, img_address m_pc)
+static char *MULT_DSP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULT %s, %s, %s", ac, rs, rt);
 }
@@ -11341,15 +11353,15 @@ static char *MULT_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *MULTU_DSP_(uint64 instruction, img_address m_pc)
+static char *MULTU_DSP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *ac = AC(copy_ui(ac_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ac = AC(copy_ui(ac_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULTU %s, %s, %s", ac, rs, rt);
 }
@@ -11365,15 +11377,15 @@ static char *MULTU_DSP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *MULU(uint64 instruction, img_address m_pc)
+static char *MULU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("MULU %s, %s, %s", rd, rs, rt);
 }
@@ -11389,13 +11401,13 @@ static char *MULU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *NEG_D(uint64 instruction, img_address m_pc)
+static char *NEG_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("NEG.D %s, %s", ft, fs);
 }
@@ -11411,13 +11423,13 @@ static char *NEG_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *NEG_S(uint64 instruction, img_address m_pc)
+static char *NEG_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("NEG.S %s, %s", ft, fs);
 }
@@ -11433,7 +11445,7 @@ static char *NEG_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *NOP_16_(uint64 instruction, img_address m_pc)
+static char *NOP_16_(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -11451,7 +11463,7 @@ static char *NOP_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *NOP_32_(uint64 instruction, img_address m_pc)
+static char *NOP_32_(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -11469,15 +11481,15 @@ static char *NOP_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *NOR(uint64 instruction, img_address m_pc)
+static char *NOR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("NOR %s, %s, %s", rd, rs, rt);
 }
@@ -11493,13 +11505,13 @@ static char *NOR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *NOT_16_(uint64 instruction, img_address m_pc)
+static char *NOT_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
 
     return img_format("NOT %s, %s", rt3, rs3);
 }
@@ -11515,13 +11527,13 @@ static char *NOT_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *OR_16_(uint64 instruction, img_address m_pc)
+static char *OR_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
 
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
 
     return img_format("OR %s, %s", rs3, rt3);
 }
@@ -11537,15 +11549,15 @@ static char *OR_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *OR_32_(uint64 instruction, img_address m_pc)
+static char *OR_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("OR %s, %s, %s", rd, rs, rt);
 }
@@ -11561,14 +11573,14 @@ static char *OR_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ORI(uint64 instruction, img_address m_pc)
+static char *ORI(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("ORI %s, %s, %s", rt, rs, u);
@@ -11586,15 +11598,15 @@ static char *ORI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PACKRL_PH(uint64 instruction, img_address m_pc)
+static char *PACKRL_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("PACKRL.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11610,7 +11622,7 @@ static char *PACKRL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PAUSE(uint64 instruction, img_address m_pc)
+static char *PAUSE(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -11629,15 +11641,15 @@ static char *PAUSE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PICK_PH(uint64 instruction, img_address m_pc)
+static char *PICK_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("PICK.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11654,15 +11666,15 @@ static char *PICK_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PICK_QB(uint64 instruction, img_address m_pc)
+static char *PICK_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("PICK.QB %s, %s, %s", rd, rs, rt);
 }
@@ -11679,13 +11691,13 @@ static char *PICK_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECEQ_W_PHL(uint64 instruction, img_address m_pc)
+static char *PRECEQ_W_PHL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PRECEQ.W.PHL %s, %s", rt, rs);
 }
@@ -11702,13 +11714,13 @@ static char *PRECEQ_W_PHL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECEQ_W_PHR(uint64 instruction, img_address m_pc)
+static char *PRECEQ_W_PHR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PRECEQ.W.PHR %s, %s", rt, rs);
 }
@@ -11725,13 +11737,13 @@ static char *PRECEQ_W_PHR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc)
+static char *PRECEQU_PH_QBLA(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PRECEQU.PH.QBLA %s, %s", rt, rs);
 }
@@ -11748,13 +11760,13 @@ static char *PRECEQU_PH_QBLA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECEQU_PH_QBL(uint64 instruction, img_address m_pc)
+static char *PRECEQU_PH_QBL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PRECEQU.PH.QBL %s, %s", rt, rs);
 }
@@ -11771,13 +11783,13 @@ static char *PRECEQU_PH_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc)
+static char *PRECEQU_PH_QBRA(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PRECEQU.PH.QBRA %s, %s", rt, rs);
 }
@@ -11794,13 +11806,13 @@ static char *PRECEQU_PH_QBRA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECEQU_PH_QBR(uint64 instruction, img_address m_pc)
+static char *PRECEQU_PH_QBR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PRECEQU.PH.QBR %s, %s", rt, rs);
 }
@@ -11818,13 +11830,13 @@ static char *PRECEQU_PH_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECEU_PH_QBLA(uint64 instruction, img_address m_pc)
+static char *PRECEU_PH_QBLA(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PRECEU.PH.QBLA %s, %s", rt, rs);
 }
@@ -11841,13 +11853,13 @@ static char *PRECEU_PH_QBLA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECEU_PH_QBL(uint64 instruction, img_address m_pc)
+static char *PRECEU_PH_QBL(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PRECEU.PH.QBL %s, %s", rt, rs);
 }
@@ -11865,13 +11877,13 @@ static char *PRECEU_PH_QBL(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECEU_PH_QBRA(uint64 instruction, img_address m_pc)
+static char *PRECEU_PH_QBRA(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PRECEU.PH.QBRA %s, %s", rt, rs);
 }
@@ -11888,13 +11900,13 @@ static char *PRECEU_PH_QBRA(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECEU_PH_QBR(uint64 instruction, img_address m_pc)
+static char *PRECEU_PH_QBR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PRECEU.PH.QBR %s, %s", rt, rs);
 }
@@ -11911,15 +11923,15 @@ static char *PRECEU_PH_QBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECR_QB_PH(uint64 instruction, img_address m_pc)
+static char *PRECR_QB_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("PRECR.QB.PH %s, %s, %s", rd, rs, rt);
 }
@@ -11936,14 +11948,14 @@ static char *PRECR_QB_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECR_SRA_PH_W(uint64 instruction, img_address m_pc)
+static char *PRECR_SRA_PH_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
@@ -11961,14 +11973,14 @@ static char *PRECR_SRA_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc)
+static char *PRECR_SRA_R_PH_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
@@ -11986,15 +11998,15 @@ static char *PRECR_SRA_R_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECRQ_PH_W(uint64 instruction, img_address m_pc)
+static char *PRECRQ_PH_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("PRECRQ.PH.W %s, %s, %s", rd, rs, rt);
 }
@@ -12011,15 +12023,15 @@ static char *PRECRQ_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECRQ_QB_PH(uint64 instruction, img_address m_pc)
+static char *PRECRQ_QB_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("PRECRQ.QB.PH %s, %s, %s", rd, rs, rt);
 }
@@ -12036,15 +12048,15 @@ static char *PRECRQ_QB_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc)
+static char *PRECRQ_RS_PH_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("PRECRQ_RS.PH.W %s, %s, %s", rd, rs, rt);
 }
@@ -12061,15 +12073,15 @@ static char *PRECRQ_RS_PH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc)
+static char *PRECRQU_S_QB_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("PRECRQU_S.QB.PH %s, %s, %s", rd, rs, rt);
 }
@@ -12085,7 +12097,7 @@ static char *PRECRQU_S_QB_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PREF_S9_(uint64 instruction, img_address m_pc)
+static char *PREF_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12093,7 +12105,7 @@ static char *PREF_S9_(uint64 instruction, img_address m_pc)
 
     g_autofree char *hint = IMMEDIATE_UI(copy_ui(hint_value));
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PREF %s, %s(%s)", hint, s, rs);
 }
@@ -12109,7 +12121,7 @@ static char *PREF_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PREF_U12_(uint64 instruction, img_address m_pc)
+static char *PREF_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12117,7 +12129,7 @@ static char *PREF_U12_(uint64 instruction, img_address m_pc)
 
     g_autofree char *hint = IMMEDIATE_UI(copy_ui(hint_value));
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PREF %s, %s(%s)", hint, u, rs);
 }
@@ -12133,7 +12145,7 @@ static char *PREF_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PREFE(uint64 instruction, img_address m_pc)
+static char *PREFE(uint64 instruction, struct Dis_info *info)
 {
     uint64 hint_value = extract_hint_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12141,7 +12153,7 @@ static char *PREFE(uint64 instruction, img_address m_pc)
 
     g_autofree char *hint = IMMEDIATE_UI(copy_ui(hint_value));
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("PREFE %s, %s(%s)", hint, s, rs);
 }
@@ -12157,14 +12169,14 @@ static char *PREFE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *PREPEND(uint64 instruction, img_address m_pc)
+static char *PREPEND(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("PREPEND %s, %s, %s", rt, rs, sa);
@@ -12180,13 +12192,13 @@ static char *PREPEND(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *RADDU_W_QB(uint64 instruction, img_address m_pc)
+static char *RADDU_W_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("RADDU.W.QB %s, %s", rt, rs);
 }
@@ -12201,12 +12213,12 @@ static char *RADDU_W_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *        mask -------
  */
-static char *RDDSP(uint64 instruction, img_address m_pc)
+static char *RDDSP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *mask = IMMEDIATE_UI(copy_ui(mask_value));
 
     return img_format("RDDSP %s, %s", rt, mask);
@@ -12223,13 +12235,13 @@ static char *RDDSP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RDHWR(uint64 instruction, img_address m_pc)
+static char *RDHWR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 hs_value = extract_hs_20_19_18_17_16(instruction);
     uint64 sel_value = extract_sel_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *hs = CPR(copy_ui(hs_value));
     g_autofree char *sel = IMMEDIATE_UI(copy_ui(sel_value));
 
@@ -12247,13 +12259,13 @@ static char *RDHWR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RDPGPR(uint64 instruction, img_address m_pc)
+static char *RDPGPR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("RDPGPR %s, %s", rt, rs);
 }
@@ -12269,13 +12281,13 @@ static char *RDPGPR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RECIP_D(uint64 instruction, img_address m_pc)
+static char *RECIP_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("RECIP.D %s, %s", ft, fs);
 }
@@ -12291,13 +12303,13 @@ static char *RECIP_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RECIP_S(uint64 instruction, img_address m_pc)
+static char *RECIP_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("RECIP.S %s, %s", ft, fs);
 }
@@ -12313,12 +12325,12 @@ static char *RECIP_S(uint64 instruction, img_address m_pc)
  *     rt -----
  *           s ----------
  */
-static char *REPL_PH(uint64 instruction, img_address m_pc)
+static char *REPL_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se9_20_19_18_17_16_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
 
     return img_format("REPL.PH %s, %s", rt, s);
@@ -12335,12 +12347,12 @@ static char *REPL_PH(uint64 instruction, img_address m_pc)
  *     rt -----
  *           u --------
  */
-static char *REPL_QB(uint64 instruction, img_address m_pc)
+static char *REPL_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_19_18_17_16_15_14_13(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("REPL.QB %s, %s", rt, u);
@@ -12357,13 +12369,13 @@ static char *REPL_QB(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *REPLV_PH(uint64 instruction, img_address m_pc)
+static char *REPLV_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("REPLV.PH %s, %s", rt, rs);
 }
@@ -12378,13 +12390,13 @@ static char *REPLV_PH(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *REPLV_QB(uint64 instruction, img_address m_pc)
+static char *REPLV_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("REPLV.QB %s, %s", rt, rs);
 }
@@ -12400,7 +12412,7 @@ static char *REPLV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RESTORE_32_(uint64 instruction, img_address m_pc)
+static char *RESTORE_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 count_value = extract_count_19_18_17_16(instruction);
@@ -12409,7 +12421,7 @@ static char *RESTORE_32_(uint64 instruction, img_address m_pc)
 
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *save_restore_str = save_restore_list(
-        rt_value, count_value, gp_value);
+        rt_value, count_value, gp_value, info);
     return img_format("RESTORE %s%s", u, save_restore_str);
 }
 
@@ -12424,7 +12436,7 @@ static char *RESTORE_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
+static char *RESTORE_JRC_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt1_value = extract_rtl_11(instruction);
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
@@ -12432,7 +12444,7 @@ static char *RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
 
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *save_restore_str = save_restore_list(
-        encode_rt1_from_rt(rt1_value), count_value, 0);
+        encode_rt1_from_rt(rt1_value), count_value, 0, info);
     return img_format("RESTORE.JRC %s%s", u, save_restore_str);
 }
 
@@ -12447,7 +12459,7 @@ static char *RESTORE_JRC_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
+static char *RESTORE_JRC_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 count_value = extract_count_19_18_17_16(instruction);
@@ -12456,7 +12468,7 @@ static char *RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
 
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *save_restore_str = save_restore_list(
-        rt_value, count_value, gp_value);
+        rt_value, count_value, gp_value, info);
     return img_format("RESTORE.JRC %s%s", u, save_restore_str);
 }
 
@@ -12471,7 +12483,7 @@ static char *RESTORE_JRC_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RESTOREF(uint64 instruction, img_address m_pc)
+static char *RESTOREF(uint64 instruction, struct Dis_info *info)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
@@ -12493,13 +12505,13 @@ static char *RESTOREF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RINT_D(uint64 instruction, img_address m_pc)
+static char *RINT_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("RINT.D %s, %s", ft, fs);
 }
@@ -12515,13 +12527,13 @@ static char *RINT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RINT_S(uint64 instruction, img_address m_pc)
+static char *RINT_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("RINT.S %s, %s", ft, fs);
 }
@@ -12537,14 +12549,14 @@ static char *RINT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ROTR(uint64 instruction, img_address m_pc)
+static char *ROTR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("ROTR %s, %s, %s", rt, rs, shift);
@@ -12561,15 +12573,15 @@ static char *ROTR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ROTRV(uint64 instruction, img_address m_pc)
+static char *ROTRV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("ROTRV %s, %s, %s", rd, rs, rt);
 }
@@ -12585,7 +12597,7 @@ static char *ROTRV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ROTX(uint64 instruction, img_address m_pc)
+static char *ROTX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -12593,8 +12605,8 @@ static char *ROTX(uint64 instruction, img_address m_pc)
     uint64 stripe_value = extract_stripe_6(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
     g_autofree char *shiftx = IMMEDIATE_UI(copy_ui(shiftx_value));
     g_autofree char *stripe = IMMEDIATE_UI(copy_ui(stripe_value));
@@ -12614,13 +12626,13 @@ static char *ROTX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ROUND_L_D(uint64 instruction, img_address m_pc)
+static char *ROUND_L_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("ROUND.L.D %s, %s", ft, fs);
 }
@@ -12636,13 +12648,13 @@ static char *ROUND_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ROUND_L_S(uint64 instruction, img_address m_pc)
+static char *ROUND_L_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("ROUND.L.S %s, %s", ft, fs);
 }
@@ -12658,13 +12670,13 @@ static char *ROUND_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ROUND_W_D(uint64 instruction, img_address m_pc)
+static char *ROUND_W_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("ROUND.W.D %s, %s", ft, fs);
 }
@@ -12680,13 +12692,13 @@ static char *ROUND_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *ROUND_W_S(uint64 instruction, img_address m_pc)
+static char *ROUND_W_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("ROUND.W.S %s, %s", ft, fs);
 }
@@ -12702,13 +12714,13 @@ static char *ROUND_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RSQRT_D(uint64 instruction, img_address m_pc)
+static char *RSQRT_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("RSQRT.D %s, %s", ft, fs);
 }
@@ -12724,13 +12736,13 @@ static char *RSQRT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *RSQRT_S(uint64 instruction, img_address m_pc)
+static char *RSQRT_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("RSQRT.S %s, %s", ft, fs);
 }
@@ -12746,7 +12758,7 @@ static char *RSQRT_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SAVE_16_(uint64 instruction, img_address m_pc)
+static char *SAVE_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt1_value = extract_rtl_11(instruction);
     uint64 u_value = extract_u_7_6_5_4__s4(instruction);
@@ -12754,7 +12766,7 @@ static char *SAVE_16_(uint64 instruction, img_address m_pc)
 
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *save_restore_str = save_restore_list(
-        encode_rt1_from_rt(rt1_value), count_value, 0);
+        encode_rt1_from_rt(rt1_value), count_value, 0, info);
     return img_format("SAVE %s%s", u, save_restore_str);
 }
 
@@ -12769,7 +12781,7 @@ static char *SAVE_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SAVE_32_(uint64 instruction, img_address m_pc)
+static char *SAVE_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
@@ -12778,7 +12790,7 @@ static char *SAVE_32_(uint64 instruction, img_address m_pc)
 
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
     g_autofree char *save_restore_str = save_restore_list(
-        rt_value, count_value, gp_value);
+        rt_value, count_value, gp_value, info);
     return img_format("SAVE %s%s", u, save_restore_str);
 }
 
@@ -12793,7 +12805,7 @@ static char *SAVE_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SAVEF(uint64 instruction, img_address m_pc)
+static char *SAVEF(uint64 instruction, struct Dis_info *info)
 {
     uint64 count_value = extract_count_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3__s3(instruction);
@@ -12815,15 +12827,15 @@ static char *SAVEF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SB_16_(uint64 instruction, img_address m_pc)
+static char *SB_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_1_0(instruction);
 
-    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
+    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
 
     return img_format("SB %s, %s(%s)", rtz3, u, rs3);
 }
@@ -12839,12 +12851,12 @@ static char *SB_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SB_GP_(uint64 instruction, img_address m_pc)
+static char *SB_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SB %s, %s($%d)", rt, u, 28);
@@ -12861,15 +12873,15 @@ static char *SB_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SB_S9_(uint64 instruction, img_address m_pc)
+static char *SB_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SB %s, %s(%s)", rt, s, rs);
 }
@@ -12885,15 +12897,15 @@ static char *SB_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SB_U12_(uint64 instruction, img_address m_pc)
+static char *SB_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SB %s, %s(%s)", rt, u, rs);
 }
@@ -12909,15 +12921,15 @@ static char *SB_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SBE(uint64 instruction, img_address m_pc)
+static char *SBE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SBE %s, %s(%s)", rt, s, rs);
 }
@@ -12933,15 +12945,15 @@ static char *SBE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SBX(uint64 instruction, img_address m_pc)
+static char *SBX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SBX %s, %s(%s)", rd, rs, rt);
 }
@@ -12957,15 +12969,15 @@ static char *SBX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SC(uint64 instruction, img_address m_pc)
+static char *SC(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SC %s, %s(%s)", rt, s, rs);
 }
@@ -12981,15 +12993,15 @@ static char *SC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SCD(uint64 instruction, img_address m_pc)
+static char *SCD(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_s3(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SCD %s, %s(%s)", rt, s, rs);
 }
@@ -13005,15 +13017,15 @@ static char *SCD(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SCDP(uint64 instruction, img_address m_pc)
+static char *SCDP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ru = GPR(copy_ui(ru_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ru = GPR(copy_ui(ru_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SCDP %s, %s, (%s)", rt, ru, rs);
 }
@@ -13029,15 +13041,15 @@ static char *SCDP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SCE(uint64 instruction, img_address m_pc)
+static char *SCE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_s2(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SCE %s, %s(%s)", rt, s, rs);
 }
@@ -13053,15 +13065,15 @@ static char *SCE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SCWP(uint64 instruction, img_address m_pc)
+static char *SCWP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ru = GPR(copy_ui(ru_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ru = GPR(copy_ui(ru_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SCWP %s, %s, (%s)", rt, ru, rs);
 }
@@ -13077,15 +13089,15 @@ static char *SCWP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SCWPE(uint64 instruction, img_address m_pc)
+static char *SCWPE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ru_value = extract_ru_7_6_5_4_3(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *ru = GPR(copy_ui(ru_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *ru = GPR(copy_ui(ru_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SCWPE %s, %s, (%s)", rt, ru, rs);
 }
@@ -13101,12 +13113,12 @@ static char *SCWPE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SD_GP_(uint64 instruction, img_address m_pc)
+static char *SD_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_3__s3(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SD %s, %s($%d)", rt, u, 28);
@@ -13123,15 +13135,15 @@ static char *SD_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SD_S9_(uint64 instruction, img_address m_pc)
+static char *SD_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SD %s, %s(%s)", rt, s, rs);
 }
@@ -13147,15 +13159,15 @@ static char *SD_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SD_U12_(uint64 instruction, img_address m_pc)
+static char *SD_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SD %s, %s(%s)", rt, u, rs);
 }
@@ -13171,7 +13183,7 @@ static char *SD_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDBBP_16_(uint64 instruction, img_address m_pc)
+static char *SDBBP_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 code_value = extract_code_2_1_0(instruction);
 
@@ -13191,7 +13203,7 @@ static char *SDBBP_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDBBP_32_(uint64 instruction, img_address m_pc)
+static char *SDBBP_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
@@ -13211,12 +13223,12 @@ static char *SDBBP_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDC1_GP_(uint64 instruction, img_address m_pc)
+static char *SDC1_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SDC1 %s, %s($%d)", ft, u, 28);
@@ -13233,15 +13245,15 @@ static char *SDC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDC1_S9_(uint64 instruction, img_address m_pc)
+static char *SDC1_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SDC1 %s, %s(%s)", ft, s, rs);
 }
@@ -13257,15 +13269,15 @@ static char *SDC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDC1_U12_(uint64 instruction, img_address m_pc)
+static char *SDC1_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SDC1 %s, %s(%s)", ft, u, rs);
 }
@@ -13281,15 +13293,15 @@ static char *SDC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDC1X(uint64 instruction, img_address m_pc)
+static char *SDC1X(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SDC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -13305,15 +13317,15 @@ static char *SDC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDC1XS(uint64 instruction, img_address m_pc)
+static char *SDC1XS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SDC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -13329,7 +13341,7 @@ static char *SDC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDC2(uint64 instruction, img_address m_pc)
+static char *SDC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -13337,7 +13349,7 @@ static char *SDC2(uint64 instruction, img_address m_pc)
 
     g_autofree char *cs = CPR(copy_ui(cs_value));
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SDC2 %s, %s(%s)", cs, s, rs);
 }
@@ -13353,16 +13365,16 @@ static char *SDC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDM(uint64 instruction, img_address m_pc)
+static char *SDM(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
         count3_value));
 
@@ -13380,13 +13392,13 @@ static char *SDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDPC_48_(uint64 instruction, img_address m_pc)
+static char *SDPC_48_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, info->m_pc);
 
     return img_format("SDPC %s, %s", rt, s);
 }
@@ -13402,15 +13414,15 @@ static char *SDPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDXS(uint64 instruction, img_address m_pc)
+static char *SDXS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SDXS %s, %s(%s)", rd, rs, rt);
 }
@@ -13426,15 +13438,15 @@ static char *SDXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SDX(uint64 instruction, img_address m_pc)
+static char *SDX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SDX %s, %s(%s)", rd, rs, rt);
 }
@@ -13450,13 +13462,13 @@ static char *SDX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SEB(uint64 instruction, img_address m_pc)
+static char *SEB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SEB %s, %s", rt, rs);
 }
@@ -13472,13 +13484,13 @@ static char *SEB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SEH(uint64 instruction, img_address m_pc)
+static char *SEH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SEH %s, %s", rt, rs);
 }
@@ -13494,15 +13506,15 @@ static char *SEH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SEL_D(uint64 instruction, img_address m_pc)
+static char *SEL_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("SEL.D %s, %s, %s", fd, fs, ft);
 }
@@ -13518,15 +13530,15 @@ static char *SEL_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SEL_S(uint64 instruction, img_address m_pc)
+static char *SEL_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("SEL.S %s, %s, %s", fd, fs, ft);
 }
@@ -13542,15 +13554,15 @@ static char *SEL_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SELEQZ_D(uint64 instruction, img_address m_pc)
+static char *SELEQZ_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("SELEQZ.D %s, %s, %s", fd, fs, ft);
 }
@@ -13566,15 +13578,15 @@ static char *SELEQZ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SELEQZ_S(uint64 instruction, img_address m_pc)
+static char *SELEQZ_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("SELEQZ.S %s, %s, %s", fd, fs, ft);
 }
@@ -13590,15 +13602,15 @@ static char *SELEQZ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SELNEZ_D(uint64 instruction, img_address m_pc)
+static char *SELNEZ_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("SELNEZ.D %s, %s, %s", fd, fs, ft);
 }
@@ -13614,15 +13626,15 @@ static char *SELNEZ_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SELNEZ_S(uint64 instruction, img_address m_pc)
+static char *SELNEZ_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("SELNEZ.S %s, %s, %s", fd, fs, ft);
 }
@@ -13638,14 +13650,14 @@ static char *SELNEZ_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SEQI(uint64 instruction, img_address m_pc)
+static char *SEQI(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SEQI %s, %s, %s", rt, rs, u);
@@ -13662,15 +13674,15 @@ static char *SEQI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SH_16_(uint64 instruction, img_address m_pc)
+static char *SH_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_2_1__s1(instruction);
 
-    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
+    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
 
     return img_format("SH %s, %s(%s)", rtz3, u, rs3);
 }
@@ -13686,12 +13698,12 @@ static char *SH_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SH_GP_(uint64 instruction, img_address m_pc)
+static char *SH_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_1__s1(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SH %s, %s($%d)", rt, u, 28);
@@ -13708,15 +13720,15 @@ static char *SH_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SH_S9_(uint64 instruction, img_address m_pc)
+static char *SH_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SH %s, %s(%s)", rt, s, rs);
 }
@@ -13732,15 +13744,15 @@ static char *SH_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SH_U12_(uint64 instruction, img_address m_pc)
+static char *SH_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SH %s, %s(%s)", rt, u, rs);
 }
@@ -13756,15 +13768,15 @@ static char *SH_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHE(uint64 instruction, img_address m_pc)
+static char *SHE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHE %s, %s(%s)", rt, s, rs);
 }
@@ -13780,13 +13792,13 @@ static char *SHE(uint64 instruction, img_address m_pc)
  *      shift ------
  *               ac --
  */
-static char *SHILO(uint64 instruction, img_address m_pc)
+static char *SHILO(uint64 instruction, struct Dis_info *info)
 {
     int64 shift_value = extract_shift__se5_21_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
     g_autofree char *shift = IMMEDIATE_I(copy_i(shift_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *ac = AC(copy_ui(ac_value), info);
 
     return img_format("SHILO %s, %s", ac, shift);
 }
@@ -13802,13 +13814,13 @@ static char *SHILO(uint64 instruction, img_address m_pc)
  *          rs -----
  *               ac --
  */
-static char *SHILOV(uint64 instruction, img_address m_pc)
+static char *SHILOV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ac_value = extract_ac_15_14(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *ac = AC(copy_ui(ac_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *ac = AC(copy_ui(ac_value), info);
 
     return img_format("SHILOV %s, %s", ac, rs);
 }
@@ -13824,14 +13836,14 @@ static char *SHILOV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ----
  */
-static char *SHLL_PH(uint64 instruction, img_address m_pc)
+static char *SHLL_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHLL.PH %s, %s, %s", rt, rs, sa);
@@ -13848,14 +13860,14 @@ static char *SHLL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ---
  */
-static char *SHLL_QB(uint64 instruction, img_address m_pc)
+static char *SHLL_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHLL.QB %s, %s, %s", rt, rs, sa);
@@ -13873,14 +13885,14 @@ static char *SHLL_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ----
  */
-static char *SHLL_S_PH(uint64 instruction, img_address m_pc)
+static char *SHLL_S_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
@@ -13897,14 +13909,14 @@ static char *SHLL_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa -----
  */
-static char *SHLL_S_W(uint64 instruction, img_address m_pc)
+static char *SHLL_S_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHLL_S.W %s, %s, %s", rt, rs, sa);
@@ -13922,15 +13934,15 @@ static char *SHLL_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHLLV_PH(uint64 instruction, img_address m_pc)
+static char *SHLLV_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHLLV.PH %s, %s, %s", rd, rt, rs);
 }
@@ -13946,15 +13958,15 @@ static char *SHLLV_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHLLV_QB(uint64 instruction, img_address m_pc)
+static char *SHLLV_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHLLV.QB %s, %s, %s", rd, rt, rs);
 }
@@ -13971,15 +13983,15 @@ static char *SHLLV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHLLV_S_PH(uint64 instruction, img_address m_pc)
+static char *SHLLV_S_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHLLV_S.PH %s, %s, %s", rd, rt, rs);
 }
@@ -13995,15 +14007,15 @@ static char *SHLLV_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHLLV_S_W(uint64 instruction, img_address m_pc)
+static char *SHLLV_S_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHLLV_S.W %s, %s, %s", rd, rt, rs);
 }
@@ -14019,14 +14031,14 @@ static char *SHLLV_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRA_PH(uint64 instruction, img_address m_pc)
+static char *SHRA_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRA.PH %s, %s, %s", rt, rs, sa);
@@ -14043,14 +14055,14 @@ static char *SHRA_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRA_QB(uint64 instruction, img_address m_pc)
+static char *SHRA_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRA.QB %s, %s, %s", rt, rs, sa);
@@ -14067,14 +14079,14 @@ static char *SHRA_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRA_R_PH(uint64 instruction, img_address m_pc)
+static char *SHRA_R_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
@@ -14091,14 +14103,14 @@ static char *SHRA_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRA_R_QB(uint64 instruction, img_address m_pc)
+static char *SHRA_R_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
@@ -14115,14 +14127,14 @@ static char *SHRA_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRA_R_W(uint64 instruction, img_address m_pc)
+static char *SHRA_R_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12_11(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRA_R.W %s, %s, %s", rt, rs, sa);
@@ -14139,15 +14151,15 @@ static char *SHRA_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRAV_PH(uint64 instruction, img_address m_pc)
+static char *SHRAV_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHRAV.PH %s, %s, %s", rd, rt, rs);
 }
@@ -14163,15 +14175,15 @@ static char *SHRAV_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRAV_QB(uint64 instruction, img_address m_pc)
+static char *SHRAV_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHRAV.QB %s, %s, %s", rd, rt, rs);
 }
@@ -14187,15 +14199,15 @@ static char *SHRAV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRAV_R_PH(uint64 instruction, img_address m_pc)
+static char *SHRAV_R_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHRAV_R.PH %s, %s, %s", rd, rt, rs);
 }
@@ -14211,15 +14223,15 @@ static char *SHRAV_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRAV_R_QB(uint64 instruction, img_address m_pc)
+static char *SHRAV_R_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHRAV_R.QB %s, %s, %s", rd, rt, rs);
 }
@@ -14235,15 +14247,15 @@ static char *SHRAV_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRAV_R_W(uint64 instruction, img_address m_pc)
+static char *SHRAV_R_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHRAV_R.W %s, %s, %s", rd, rt, rs);
 }
@@ -14259,14 +14271,14 @@ static char *SHRAV_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ----
  */
-static char *SHRL_PH(uint64 instruction, img_address m_pc)
+static char *SHRL_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRL.PH %s, %s, %s", rt, rs, sa);
@@ -14283,14 +14295,14 @@ static char *SHRL_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               sa ---
  */
-static char *SHRL_QB(uint64 instruction, img_address m_pc)
+static char *SHRL_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 sa_value = extract_sa_15_14_13(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *sa = IMMEDIATE_UI(copy_ui(sa_value));
 
     return img_format("SHRL.QB %s, %s, %s", rt, rs, sa);
@@ -14308,15 +14320,15 @@ static char *SHRL_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRLV_PH(uint64 instruction, img_address m_pc)
+static char *SHRLV_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHRLV.PH %s, %s, %s", rd, rt, rs);
 }
@@ -14332,15 +14344,15 @@ static char *SHRLV_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHRLV_QB(uint64 instruction, img_address m_pc)
+static char *SHRLV_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SHRLV.QB %s, %s, %s", rd, rt, rs);
 }
@@ -14356,15 +14368,15 @@ static char *SHRLV_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHX(uint64 instruction, img_address m_pc)
+static char *SHX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SHX %s, %s(%s)", rd, rs, rt);
 }
@@ -14380,15 +14392,15 @@ static char *SHX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SHXS(uint64 instruction, img_address m_pc)
+static char *SHXS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SHXS %s, %s(%s)", rd, rs, rt);
 }
@@ -14404,7 +14416,7 @@ static char *SHXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SIGRIE(uint64 instruction, img_address m_pc)
+static char *SIGRIE(uint64 instruction, struct Dis_info *info)
 {
     uint64 code_value = extract_code_18_to_0(instruction);
 
@@ -14424,14 +14436,14 @@ static char *SIGRIE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SLL_16_(uint64 instruction, img_address m_pc)
+static char *SLL_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 shift3_value = extract_shift3_2_1_0(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
     g_autofree char *shift3 = IMMEDIATE_UI(encode_shift3_from_shift(
         shift3_value));
 
@@ -14449,14 +14461,14 @@ static char *SLL_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SLL_32_(uint64 instruction, img_address m_pc)
+static char *SLL_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("SLL %s, %s, %s", rt, rs, shift);
@@ -14473,15 +14485,15 @@ static char *SLL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SLLV(uint64 instruction, img_address m_pc)
+static char *SLLV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SLLV %s, %s, %s", rd, rs, rt);
 }
@@ -14497,15 +14509,15 @@ static char *SLLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SLT(uint64 instruction, img_address m_pc)
+static char *SLT(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SLT %s, %s, %s", rd, rs, rt);
 }
@@ -14521,14 +14533,14 @@ static char *SLT(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SLTI(uint64 instruction, img_address m_pc)
+static char *SLTI(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SLTI %s, %s, %s", rt, rs, u);
@@ -14545,14 +14557,14 @@ static char *SLTI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SLTIU(uint64 instruction, img_address m_pc)
+static char *SLTIU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SLTIU %s, %s, %s", rt, rs, u);
@@ -14569,15 +14581,15 @@ static char *SLTIU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SLTU(uint64 instruction, img_address m_pc)
+static char *SLTU(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SLTU %s, %s, %s", rd, rs, rt);
 }
@@ -14593,15 +14605,15 @@ static char *SLTU(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SOV(uint64 instruction, img_address m_pc)
+static char *SOV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SOV %s, %s, %s", rd, rs, rt);
 }
@@ -14617,7 +14629,7 @@ static char *SOV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SPECIAL2(uint64 instruction, img_address m_pc)
+static char *SPECIAL2(uint64 instruction, struct Dis_info *info)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
@@ -14637,13 +14649,13 @@ static char *SPECIAL2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SQRT_D(uint64 instruction, img_address m_pc)
+static char *SQRT_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("SQRT.D %s, %s", ft, fs);
 }
@@ -14659,13 +14671,13 @@ static char *SQRT_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SQRT_S(uint64 instruction, img_address m_pc)
+static char *SQRT_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("SQRT.S %s, %s", ft, fs);
 }
@@ -14681,14 +14693,14 @@ static char *SQRT_S(uint64 instruction, img_address m_pc)
  *               rd -----
  *                    sa -----
  */
-static char *SRA(uint64 instruction, img_address m_pc)
+static char *SRA(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("SRA %s, %s, %s", rt, rs, shift);
@@ -14705,15 +14717,15 @@ static char *SRA(uint64 instruction, img_address m_pc)
  *          rt -----
  *               rd -----
  */
-static char *SRAV(uint64 instruction, img_address m_pc)
+static char *SRAV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SRAV %s, %s, %s", rd, rs, rt);
 }
@@ -14729,14 +14741,14 @@ static char *SRAV(uint64 instruction, img_address m_pc)
  *          rt -----
  *               rd -----
  */
-static char *SRL_16_(uint64 instruction, img_address m_pc)
+static char *SRL_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 shift3_value = extract_shift3_2_1_0(instruction);
 
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
     g_autofree char *shift3 = IMMEDIATE_UI(encode_shift3_from_shift(
         shift3_value));
 
@@ -14754,14 +14766,14 @@ static char *SRL_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SRL_32_(uint64 instruction, img_address m_pc)
+static char *SRL_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 shift_value = extract_shift_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *shift = IMMEDIATE_UI(copy_ui(shift_value));
 
     return img_format("SRL %s, %s, %s", rt, rs, shift);
@@ -14778,15 +14790,15 @@ static char *SRL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SRLV(uint64 instruction, img_address m_pc)
+static char *SRLV(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SRLV %s, %s, %s", rd, rs, rt);
 }
@@ -14802,15 +14814,15 @@ static char *SRLV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUB(uint64 instruction, img_address m_pc)
+static char *SUB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUB %s, %s, %s", rd, rs, rt);
 }
@@ -14826,15 +14838,15 @@ static char *SUB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUB_D(uint64 instruction, img_address m_pc)
+static char *SUB_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("SUB.D %s, %s, %s", fd, fs, ft);
 }
@@ -14850,15 +14862,15 @@ static char *SUB_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUB_S(uint64 instruction, img_address m_pc)
+static char *SUB_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
     uint64 fd_value = extract_fd_15_14_13_12_11(instruction);
 
-    const char *fd = FPR(copy_ui(fd_value));
-    const char *fs = FPR(copy_ui(fs_value));
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *fd = FPR(copy_ui(fd_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
+    const char *ft = FPR(copy_ui(ft_value), info);
 
     return img_format("SUB.S %s, %s, %s", fd, fs, ft);
 }
@@ -14874,15 +14886,15 @@ static char *SUB_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBQ_PH(uint64 instruction, img_address m_pc)
+static char *SUBQ_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBQ.PH %s, %s, %s", rd, rs, rt);
 }
@@ -14899,15 +14911,15 @@ static char *SUBQ_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBQ_S_PH(uint64 instruction, img_address m_pc)
+static char *SUBQ_S_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBQ_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -14924,15 +14936,15 @@ static char *SUBQ_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBQ_S_W(uint64 instruction, img_address m_pc)
+static char *SUBQ_S_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBQ_S.W %s, %s, %s", rd, rs, rt);
 }
@@ -14949,15 +14961,15 @@ static char *SUBQ_S_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBQH_PH(uint64 instruction, img_address m_pc)
+static char *SUBQH_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBQH.PH %s, %s, %s", rd, rs, rt);
 }
@@ -14974,15 +14986,15 @@ static char *SUBQH_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBQH_R_PH(uint64 instruction, img_address m_pc)
+static char *SUBQH_R_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBQH_R.PH %s, %s, %s", rd, rs, rt);
 }
@@ -14999,15 +15011,15 @@ static char *SUBQH_R_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBQH_R_W(uint64 instruction, img_address m_pc)
+static char *SUBQH_R_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBQH_R.W %s, %s, %s", rd, rs, rt);
 }
@@ -15024,15 +15036,15 @@ static char *SUBQH_R_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBQH_W(uint64 instruction, img_address m_pc)
+static char *SUBQH_W(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBQH.W %s, %s, %s", rd, rs, rt);
 }
@@ -15048,15 +15060,15 @@ static char *SUBQH_W(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBU_16_(uint64 instruction, img_address m_pc)
+static char *SUBU_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 rd3_value = extract_rd3_3_2_1(instruction);
 
-    const char *rd3 = GPR(decode_gpr_gpr3(rd3_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rd3 = GPR(decode_gpr_gpr3(rd3_value, info), info);
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
 
     return img_format("SUBU %s, %s, %s", rd3, rs3, rt3);
 }
@@ -15072,15 +15084,15 @@ static char *SUBU_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBU_32_(uint64 instruction, img_address m_pc)
+static char *SUBU_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBU %s, %s, %s", rd, rs, rt);
 }
@@ -15096,15 +15108,15 @@ static char *SUBU_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBU_PH(uint64 instruction, img_address m_pc)
+static char *SUBU_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBU.PH %s, %s, %s", rd, rs, rt);
 }
@@ -15120,15 +15132,15 @@ static char *SUBU_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBU_QB(uint64 instruction, img_address m_pc)
+static char *SUBU_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBU.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15145,15 +15157,15 @@ static char *SUBU_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBU_S_PH(uint64 instruction, img_address m_pc)
+static char *SUBU_S_PH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBU_S.PH %s, %s, %s", rd, rs, rt);
 }
@@ -15170,15 +15182,15 @@ static char *SUBU_S_PH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBU_S_QB(uint64 instruction, img_address m_pc)
+static char *SUBU_S_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBU_S.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15195,15 +15207,15 @@ static char *SUBU_S_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBUH_QB(uint64 instruction, img_address m_pc)
+static char *SUBUH_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBUH.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15220,15 +15232,15 @@ static char *SUBUH_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SUBUH_R_QB(uint64 instruction, img_address m_pc)
+static char *SUBUH_R_QB(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SUBUH_R.QB %s, %s, %s", rd, rs, rt);
 }
@@ -15244,15 +15256,15 @@ static char *SUBUH_R_QB(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SW_16_(uint64 instruction, img_address m_pc)
+static char *SW_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
     uint64 u_value = extract_u_3_2_1_0__s2(instruction);
 
-    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
+    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
 
     return img_format("SW %s, %s(%s)", rtz3, u, rs3);
 }
@@ -15268,15 +15280,15 @@ static char *SW_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SW_4X4_(uint64 instruction, img_address m_pc)
+static char *SW_4X4_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rtz4_value = extract_rtz4_9_7_6_5(instruction);
     uint64 rs4_value = extract_rs4_4_2_1_0(instruction);
     uint64 u_value = extract_u_3_8__s2(instruction);
 
-    const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
+    const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value));
+    const char *rs4 = GPR(decode_gpr_gpr4(rs4_value, info), info);
 
     return img_format("SW %s, %s(%s)", rtz4, u, rs4);
 }
@@ -15292,12 +15304,12 @@ static char *SW_4X4_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SW_GP16_(uint64 instruction, img_address m_pc)
+static char *SW_GP16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 u_value = extract_u_6_5_4_3_2_1_0__s2(instruction);
     uint64 rtz3_value = extract_rtz3_9_8_7(instruction);
 
-    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
+    const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value, info), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SW %s, %s($%d)", rtz3, u, 28);
@@ -15314,12 +15326,12 @@ static char *SW_GP16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SW_GP_(uint64 instruction, img_address m_pc)
+static char *SW_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_20_to_2__s2(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SW %s, %s($%d)", rt, u, 28);
@@ -15336,15 +15348,15 @@ static char *SW_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SW_S9_(uint64 instruction, img_address m_pc)
+static char *SW_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SW %s, %s(%s)", rt, s, rs);
 }
@@ -15360,12 +15372,12 @@ static char *SW_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SW_SP_(uint64 instruction, img_address m_pc)
+static char *SW_SP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_9_8_7_6_5(instruction);
     uint64 u_value = extract_u_4_3_2_1_0__s2(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SW %s, %s($%d)", rt, u, 29);
@@ -15382,15 +15394,15 @@ static char *SW_SP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SW_U12_(uint64 instruction, img_address m_pc)
+static char *SW_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SW %s, %s(%s)", rt, u, rs);
 }
@@ -15406,12 +15418,12 @@ static char *SW_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SWC1_GP_(uint64 instruction, img_address m_pc)
+static char *SWC1_GP_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 u_value = extract_u_17_to_2__s2(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("SWC1 %s, %s($%d)", ft, u, 28);
@@ -15428,15 +15440,15 @@ static char *SWC1_GP_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SWC1_S9_(uint64 instruction, img_address m_pc)
+static char *SWC1_S9_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SWC1 %s, %s(%s)", ft, s, rs);
 }
@@ -15452,15 +15464,15 @@ static char *SWC1_S9_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SWC1_U12_(uint64 instruction, img_address m_pc)
+static char *SWC1_U12_(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SWC1 %s, %s(%s)", ft, u, rs);
 }
@@ -15476,15 +15488,15 @@ static char *SWC1_U12_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SWC1X(uint64 instruction, img_address m_pc)
+static char *SWC1X(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SWC1X %s, %s(%s)", ft, rs, rt);
 }
@@ -15500,15 +15512,15 @@ static char *SWC1X(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SWC1XS(uint64 instruction, img_address m_pc)
+static char *SWC1XS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 ft_value = extract_ft_15_14_13_12_11(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SWC1XS %s, %s(%s)", ft, rs, rt);
 }
@@ -15524,7 +15536,7 @@ static char *SWC1XS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SWC2(uint64 instruction, img_address m_pc)
+static char *SWC2(uint64 instruction, struct Dis_info *info)
 {
     uint64 cs_value = extract_cs_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
@@ -15532,7 +15544,7 @@ static char *SWC2(uint64 instruction, img_address m_pc)
 
     g_autofree char *cs = CPR(copy_ui(cs_value));
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SWC2 %s, %s(%s)", cs, s, rs);
 }
@@ -15548,15 +15560,15 @@ static char *SWC2(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SWE(uint64 instruction, img_address m_pc)
+static char *SWE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SWE %s, %s(%s)", rt, s, rs);
 }
@@ -15572,16 +15584,16 @@ static char *SWE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SWM(uint64 instruction, img_address m_pc)
+static char *SWM(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
         count3_value));
 
@@ -15599,13 +15611,13 @@ static char *SWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SWPC_48_(uint64 instruction, img_address m_pc)
+static char *SWPC_48_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_41_40_39_38_37(instruction);
     int64 s_value = extract_s__se31_15_to_0_31_to_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, m_pc);
+    const char *rt = GPR(copy_ui(rt_value), info);
+    g_autofree char *s = ADDRESS(encode_s_from_address(s_value), 6, info->m_pc);
 
     return img_format("SWPC %s, %s", rt, s);
 }
@@ -15621,15 +15633,15 @@ static char *SWPC_48_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SWX(uint64 instruction, img_address m_pc)
+static char *SWX(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SWX %s, %s(%s)", rd, rs, rt);
 }
@@ -15645,15 +15657,15 @@ static char *SWX(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SWXS(uint64 instruction, img_address m_pc)
+static char *SWXS(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("SWXS %s, %s(%s)", rd, rs, rt);
 }
@@ -15669,7 +15681,7 @@ static char *SWXS(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SYNC(uint64 instruction, img_address m_pc)
+static char *SYNC(uint64 instruction, struct Dis_info *info)
 {
     uint64 stype_value = extract_stype_20_19_18_17_16(instruction);
 
@@ -15689,13 +15701,13 @@ static char *SYNC(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SYNCI(uint64 instruction, img_address m_pc)
+static char *SYNCI(uint64 instruction, struct Dis_info *info)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SYNCI %s(%s)", s, rs);
 }
@@ -15711,13 +15723,13 @@ static char *SYNCI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SYNCIE(uint64 instruction, img_address m_pc)
+static char *SYNCIE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("SYNCIE %s(%s)", s, rs);
 }
@@ -15733,7 +15745,7 @@ static char *SYNCIE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *SYSCALL_16_(uint64 instruction, img_address m_pc)
+static char *SYSCALL_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 code_value = extract_code_1_0(instruction);
 
@@ -15751,7 +15763,7 @@ static char *SYSCALL_16_(uint64 instruction, img_address m_pc)
  *  00000000000010
  *           code ------------------
  */
-static char *SYSCALL_32_(uint64 instruction, img_address m_pc)
+static char *SYSCALL_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 code_value = extract_code_17_to_0(instruction);
 
@@ -15771,13 +15783,13 @@ static char *SYSCALL_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TEQ(uint64 instruction, img_address m_pc)
+static char *TEQ(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("TEQ %s, %s", rs, rt);
 }
@@ -15793,7 +15805,7 @@ static char *TEQ(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBGINV(uint64 instruction, img_address m_pc)
+static char *TLBGINV(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -15811,7 +15823,7 @@ static char *TLBGINV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBGINVF(uint64 instruction, img_address m_pc)
+static char *TLBGINVF(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -15829,7 +15841,7 @@ static char *TLBGINVF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBGP(uint64 instruction, img_address m_pc)
+static char *TLBGP(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -15847,7 +15859,7 @@ static char *TLBGP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBGR(uint64 instruction, img_address m_pc)
+static char *TLBGR(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -15865,7 +15877,7 @@ static char *TLBGR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBGWI(uint64 instruction, img_address m_pc)
+static char *TLBGWI(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -15883,7 +15895,7 @@ static char *TLBGWI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBGWR(uint64 instruction, img_address m_pc)
+static char *TLBGWR(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -15901,7 +15913,7 @@ static char *TLBGWR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBINV(uint64 instruction, img_address m_pc)
+static char *TLBINV(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -15919,7 +15931,7 @@ static char *TLBINV(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBINVF(uint64 instruction, img_address m_pc)
+static char *TLBINVF(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -15937,7 +15949,7 @@ static char *TLBINVF(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBP(uint64 instruction, img_address m_pc)
+static char *TLBP(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -15955,7 +15967,7 @@ static char *TLBP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBR(uint64 instruction, img_address m_pc)
+static char *TLBR(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -15973,7 +15985,7 @@ static char *TLBR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBWI(uint64 instruction, img_address m_pc)
+static char *TLBWI(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -15991,7 +16003,7 @@ static char *TLBWI(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TLBWR(uint64 instruction, img_address m_pc)
+static char *TLBWR(uint64 instruction, struct Dis_info *info)
 {
     (void)instruction;
 
@@ -16009,13 +16021,13 @@ static char *TLBWR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TNE(uint64 instruction, img_address m_pc)
+static char *TNE(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("TNE %s, %s", rs, rt);
 }
@@ -16031,13 +16043,13 @@ static char *TNE(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TRUNC_L_D(uint64 instruction, img_address m_pc)
+static char *TRUNC_L_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("TRUNC.L.D %s, %s", ft, fs);
 }
@@ -16053,13 +16065,13 @@ static char *TRUNC_L_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TRUNC_L_S(uint64 instruction, img_address m_pc)
+static char *TRUNC_L_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("TRUNC.L.S %s, %s", ft, fs);
 }
@@ -16075,13 +16087,13 @@ static char *TRUNC_L_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TRUNC_W_D(uint64 instruction, img_address m_pc)
+static char *TRUNC_W_D(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("TRUNC.W.D %s, %s", ft, fs);
 }
@@ -16097,13 +16109,13 @@ static char *TRUNC_W_D(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *TRUNC_W_S(uint64 instruction, img_address m_pc)
+static char *TRUNC_W_S(uint64 instruction, struct Dis_info *info)
 {
     uint64 ft_value = extract_ft_25_24_23_22_21(instruction);
     uint64 fs_value = extract_fs_20_19_18_17_16(instruction);
 
-    const char *ft = FPR(copy_ui(ft_value));
-    const char *fs = FPR(copy_ui(fs_value));
+    const char *ft = FPR(copy_ui(ft_value), info);
+    const char *fs = FPR(copy_ui(fs_value), info);
 
     return img_format("TRUNC.W.S %s, %s", ft, fs);
 }
@@ -16119,16 +16131,16 @@ static char *TRUNC_W_S(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *UALDM(uint64 instruction, img_address m_pc)
+static char *UALDM(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
         count3_value));
 
@@ -16146,15 +16158,15 @@ static char *UALDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *UALH(uint64 instruction, img_address m_pc)
+static char *UALH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("UALH %s, %s(%s)", rt, s, rs);
 }
@@ -16170,16 +16182,16 @@ static char *UALH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *UALWM(uint64 instruction, img_address m_pc)
+static char *UALWM(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
         count3_value));
 
@@ -16197,16 +16209,16 @@ static char *UALWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *UASDM(uint64 instruction, img_address m_pc)
+static char *UASDM(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
         count3_value));
 
@@ -16224,15 +16236,15 @@ static char *UASDM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *UASH(uint64 instruction, img_address m_pc)
+static char *UASH(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("UASH %s, %s(%s)", rt, s, rs);
 }
@@ -16248,16 +16260,16 @@ static char *UASH(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *UASWM(uint64 instruction, img_address m_pc)
+static char *UASWM(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     int64 s_value = extract_s__se8_15_7_6_5_4_3_2_1_0(instruction);
     uint64 count3_value = extract_count3_14_13_12(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *s = IMMEDIATE_I(copy_i(s_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *count3 = IMMEDIATE_UI(encode_count3_from_count(
         count3_value));
 
@@ -16275,7 +16287,7 @@ static char *UASWM(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *UDI(uint64 instruction, img_address m_pc)
+static char *UDI(uint64 instruction, struct Dis_info *info)
 {
     uint64 op_value = extract_op_25_to_3(instruction);
 
@@ -16293,7 +16305,7 @@ static char *UDI(uint64 instruction, img_address m_pc)
  *  001000          1100001101111111
  *   code ----------
  */
-static char *WAIT(uint64 instruction, img_address m_pc)
+static char *WAIT(uint64 instruction, struct Dis_info *info)
 {
     uint64 code_value = extract_code_25_24_23_22_21_20_19_18_17_16(instruction);
 
@@ -16313,12 +16325,12 @@ static char *WAIT(uint64 instruction, img_address m_pc)
  *     rt -----
  *        mask -------
  */
-static char *WRDSP(uint64 instruction, img_address m_pc)
+static char *WRDSP(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 mask_value = extract_mask_20_19_18_17_16_15_14(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
     g_autofree char *mask = IMMEDIATE_UI(copy_ui(mask_value));
 
     return img_format("WRDSP %s, %s", rt, mask);
@@ -16335,13 +16347,13 @@ static char *WRDSP(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *WRPGPR(uint64 instruction, img_address m_pc)
+static char *WRPGPR(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("WRPGPR %s, %s", rt, rs);
 }
@@ -16357,13 +16369,13 @@ static char *WRPGPR(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *XOR_16_(uint64 instruction, img_address m_pc)
+static char *XOR_16_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt3_value = extract_rt3_9_8_7(instruction);
     uint64 rs3_value = extract_rs3_6_5_4(instruction);
 
-    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
-    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
+    const char *rs3 = GPR(decode_gpr_gpr3(rs3_value, info), info);
+    const char *rt3 = GPR(decode_gpr_gpr3(rt3_value, info), info);
 
     return img_format("XOR %s, %s", rs3, rt3);
 }
@@ -16379,15 +16391,15 @@ static char *XOR_16_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *XOR_32_(uint64 instruction, img_address m_pc)
+static char *XOR_32_(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 rd_value = extract_rd_15_14_13_12_11(instruction);
 
-    const char *rd = GPR(copy_ui(rd_value));
-    const char *rs = GPR(copy_ui(rs_value));
-    const char *rt = GPR(copy_ui(rt_value));
+    const char *rd = GPR(copy_ui(rd_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
+    const char *rt = GPR(copy_ui(rt_value), info);
 
     return img_format("XOR %s, %s, %s", rd, rs, rt);
 }
@@ -16403,14 +16415,14 @@ static char *XOR_32_(uint64 instruction, img_address m_pc)
  *          rs -----
  *               rd -----
  */
-static char *XORI(uint64 instruction, img_address m_pc)
+static char *XORI(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
     uint64 u_value = extract_u_11_10_9_8_7_6_5_4_3_2_1_0(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
     g_autofree char *u = IMMEDIATE_UI(copy_ui(u_value));
 
     return img_format("XORI %s, %s, %s", rt, rs, u);
@@ -16426,13 +16438,13 @@ static char *XORI(uint64 instruction, img_address m_pc)
  *     rt -----
  *          rs -----
  */
-static char *YIELD(uint64 instruction, img_address m_pc)
+static char *YIELD(uint64 instruction, struct Dis_info *info)
 {
     uint64 rt_value = extract_rt_25_24_23_22_21(instruction);
     uint64 rs_value = extract_rs_20_19_18_17_16(instruction);
 
-    const char *rt = GPR(copy_ui(rt_value));
-    const char *rs = GPR(copy_ui(rs_value));
+    const char *rt = GPR(copy_ui(rt_value), info);
+    const char *rs = GPR(copy_ui(rs_value), info);
 
     return img_format("YIELD %s, %s", rt, rs);
 }
@@ -22237,7 +22249,7 @@ static struct Pool MAJOR[2] = {
 
 
 static int nanomips_dis(char *buf,
-                 unsigned address,
+                 struct Dis_info *info,
                  unsigned short one,
                  unsigned short two,
                  unsigned short three)
@@ -22246,7 +22258,7 @@ static int nanomips_dis(char *buf,
     uint16 bits[3] = {one, two, three};
 
     TABLE_ENTRY_TYPE type;
-    int size = Disassemble(bits, disasm, type, MAJOR, 2, address);
+    int size = Disassemble(bits, disasm, type, MAJOR, 2, info);
 
     strcpy(buf, disasm);
     return size;
@@ -22268,6 +22280,11 @@ int print_insn_nanomips(bfd_vma memaddr, struct disassemble_info *info)
     info->target = 0;
     info->target2 = 0;
 
+    struct Dis_info disassm_info;
+    disassm_info.m_pc = memaddr;
+    disassm_info.fprintf_func = info->fprintf_func;
+    disassm_info.stream = info->stream;
+
     status = (*info->read_memory_func)(memaddr, buffer, 2, info);
     if (status != 0) {
         (*info->memory_error_func)(status, memaddr, info);
@@ -22316,7 +22333,7 @@ int print_insn_nanomips(bfd_vma memaddr, struct disassemble_info *info)
         (*info->fprintf_func)(info->stream, "     ");
     }
 
-    int length = nanomips_dis(buf, memaddr, insn1, insn2, insn3);
+    int length = nanomips_dis(buf, &disassm_info, insn1, insn2, insn3);
 
     /* FIXME: Should probably use a hash table on the major opcode here.  */
 
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 15/20] disas/nanomips: Introduce Dis_info struct
  2022-09-05  9:55 ` [PATCH v2 15/20] disas/nanomips: Introduce Dis_info struct Milica Lazarevic
@ 2022-09-05 11:55   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:55 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> This patch introduces the Dis_info struct, which should hold the
> necessary data for handling runtime errors. Fields fprintf_func and
> stream are in charge of error printing. Field buf enables the use of
> sigsetjmp() and siglongjmp() functions. Support for runtime error
> handling will be added later.
> 
> Parameter m_pc, which we need for address calculation, is integrated
> into the Dis_info struct.
> 
> We're filling Dis_info at the entrance of the nanoMIPS disassembler,
> i.e. print_insn_nanomips. Next, we're adding that information as an
> argument wherever we need to.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> ---
>   disas/nanomips.cpp | 4083 ++++++++++++++++++++++----------------------
>   1 file changed, 2050 insertions(+), 2033 deletions(-)
> 
> diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
> index 9e34ca164c..5142f307fc 100644
> --- a/disas/nanomips.cpp
> +++ b/disas/nanomips.cpp
> @@ -41,9 +41,16 @@ typedef uint32_t uint32;
>   typedef uint16_t uint16;
>   typedef uint64_t img_address;
>   
> +struct Dis_info {
> +  img_address m_pc;
> +  fprintf_function fprintf_func;
> +  FILE *stream;
> +  sigjmp_buf buf;
> +};

As mentioned vs patch 3, this structure should be introduced much earlier, which 
eliminates almost all of this patch.  What remains appears to be specific to the next 
patch, for exception handling, and you would merge this into that.


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 16/20] disas/nanomips: Replace exception handling
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (14 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 15/20] disas/nanomips: Introduce Dis_info struct Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:50   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 17/20] disas/nanomips: Replace Cpp enums for C enums Milica Lazarevic
                   ` (3 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

Since there's no support for exception handling in C, the try-catch
blocks have been deleted, and throw clauses are replaced. When a runtime
error happens, we're printing out the error message. Disassembling of
the current instruction interrupts. This behavior is achieved by adding
sigsetjmp() to discard further disassembling after the error message
prints and by adding the siglongjmp() function to imitate throwing an
error. The goal was to maintain the same output as it was.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
---
 disas/nanomips.cpp | 126 ++++++++++++++++++++++-----------------------
 1 file changed, 61 insertions(+), 65 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index 5142f307fc..a8295ebfa8 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -31,7 +31,6 @@
 #include "disas/dis-asm.h"
 
 #include <string.h>
-#include <stdexcept>
 #include <stdio.h>
 #include <stdarg.h>
 
@@ -134,10 +133,12 @@ static uint64 renumber_registers(uint64 index, uint64 *register_list,
         return register_list[index];
     }
 
-    throw std::runtime_error(img_format(
-                   "Invalid register mapping index %" PRIu64
-                   ", size of list = %zu",
-                   index, register_list_size));
+    g_autofree char *err = img_format(
+                      "Invalid register mapping index %" PRIu64
+                      ", size of list = %zu",
+                      index, register_list_size);
+    info->fprintf_func(info->stream, "%s", err);
+    siglongjmp(info->buf, 1);
 }
 
 
@@ -514,8 +515,10 @@ static const char *GPR(uint64 reg, struct Dis_info *info)
         return gpr_reg[reg];
     }
 
-    throw std::runtime_error(img_format("Invalid GPR register index %" PRIu64,
-                                         reg));
+    g_autofree char *err = img_format("Invalid GPR register index %" PRIu64,
+                                 reg);
+    info->fprintf_func(info->stream, "%s", err);
+    siglongjmp(info->buf, 1);
 }
 
 
@@ -553,8 +556,10 @@ static const char *FPR(uint64 reg, struct Dis_info *info)
         return fpr_reg[reg];
     }
 
-    throw std::runtime_error(img_format("Invalid FPR register index %" PRIu64,
-                                         reg));
+    g_autofree const char *err = img_format(
+        "Invalid FPR register index %" PRIu64, reg);
+    info->fprintf_func(info->stream, "%s", err);
+    siglongjmp(info->buf, 1);
 }
 
 
@@ -568,8 +573,10 @@ static const char *AC(uint64 reg, struct Dis_info *info)
         return ac_reg[reg];
     }
 
-    throw std::runtime_error(img_format("Invalid AC register index %" PRIu64,
-                                         reg));
+    const char *err = img_format("Invalid AC register index %" PRIu64,
+                                 reg);
+    info->fprintf_func(info->stream, "%s", err);
+    siglongjmp(info->buf, 1);
 }
 
 
@@ -631,65 +638,48 @@ static int Disassemble(const uint16 *data, char *dis,
                        TABLE_ENTRY_TYPE & type, const Pool *table,
                        int table_size, struct Dis_info *info)
 {
-    try
-    {
-        for (int i = 0; i < table_size; i++) {
-            uint64 op_code = extract_op_code_value(data,
-                                 table[i].instructions_size);
-            if ((op_code & table[i].mask) == table[i].value) {
-                /* possible match */
-                conditional_function cond = table[i].condition;
-                if ((cond == NULL) || cond(op_code)) {
-                    try
-                    {
-                        if (table[i].type == pool) {
-                            return Disassemble(data, dis, type,
-                                               table[i].next_table,
-                                               table[i].next_table_size, info);
-                        } else if ((table[i].type == instruction) ||
-                                   (table[i].type == call_instruction) ||
-                                   (table[i].type == branch_instruction) ||
-                                   (table[i].type == return_instruction)) {
-                            if ((table[i].attributes != 0) &&
-                                (ALL_ATTRIBUTES & table[i].attributes) == 0) {
-                                /*
-                                 * failed due to instruction having
-                                 * an ASE attribute and the requested version
-                                 * not having that attribute
-                                 */
-                                strcpy(dis, "ASE attribute mismatch");
-                                return -5;
-                            }
-                            disassembly_function dis_fn = table[i].disassembly;
-                            if (dis_fn == 0) {
-                                strcpy(dis,
-                                "disassembler failure - bad table entry");
-                                return -6;
-                            }
-                            type = table[i].type;
-                            g_autofree char *dis_str = dis_fn(op_code, info);
-                            strcpy(dis, dis_str);
-                            return table[i].instructions_size;
-                        } else {
-                            strcpy(dis, "reserved instruction");
-                            return -2;
+    for (int i = 0; i < table_size; i++) {
+        uint64 op_code = extract_op_code_value(data,
+                             table[i].instructions_size);
+        if ((op_code & table[i].mask) == table[i].value) {
+            /* possible match */
+            conditional_function cond = table[i].condition;
+            if ((cond == NULL) || cond(op_code)) {
+                if (table[i].type == pool) {
+                    return Disassemble(data, dis, type,
+                                       table[i].next_table,
+                                       table[i].next_table_size, info);
+                } else if ((table[i].type == instruction) ||
+                           (table[i].type == call_instruction) ||
+                           (table[i].type == branch_instruction) ||
+                           (table[i].type == return_instruction)) {
+                        if ((table[i].attributes != 0) &&
+                            (ALL_ATTRIBUTES & table[i].attributes) == 0) {
+                            /*
+                             * failed due to instruction having
+                             * an ASE attribute and the requested version
+                             * not having that attribute
+                             */
+                            strcpy(dis, "ASE attribute mismatch");
+                            return -5;
                         }
-                    }
-                    catch (std::runtime_error & e)
-                    {
-                        strcpy(dis, e.what());
-                        return -3;          /* runtime error */
+                        disassembly_function dis_fn = table[i].disassembly;
+                        if (dis_fn == 0) {
+                            strcpy(dis,
+                            "disassembler failure - bad table entry");
+                            return -6;
+                        }
+                        type = table[i].type;
+                        g_autofree char *dis_str = dis_fn(op_code, info);
+                        strcpy(dis, dis_str);
+                        return table[i].instructions_size;
+                    } else {
+                        strcpy(dis, "reserved instruction");
+                        return -2;
                     }
                 }
             }
         }
-    }
-    catch (std::exception & e)
-    {
-        strcpy(dis, e.what());
-        return -4;          /* runtime error */
-    }
-
     strcpy(dis, "failed to disassemble");
     return -1;      /* failed to disassemble        */
 }
@@ -22333,6 +22323,12 @@ int print_insn_nanomips(bfd_vma memaddr, struct disassemble_info *info)
         (*info->fprintf_func)(info->stream, "     ");
     }
 
+    /* Handle runtime errors. */
+    if (sigsetjmp(disassm_info.buf, 0) != 0) {
+        info->insn_type = dis_noninsn;
+        return insn3 ? 6 : insn2 ? 4 : 2;
+    }
+
     int length = nanomips_dis(buf, &disassm_info, insn1, insn2, insn3);
 
     /* FIXME: Should probably use a hash table on the major opcode here.  */
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 16/20] disas/nanomips: Replace exception handling
  2022-09-05  9:55 ` [PATCH v2 16/20] disas/nanomips: Replace exception handling Milica Lazarevic
@ 2022-09-05 11:50   ` Richard Henderson
  2022-09-07 17:09     ` Milica Lazarevic
  0 siblings, 1 reply; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:50 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> Since there's no support for exception handling in C, the try-catch
> blocks have been deleted, and throw clauses are replaced. When a runtime
> error happens, we're printing out the error message. Disassembling of
> the current instruction interrupts. This behavior is achieved by adding
> sigsetjmp() to discard further disassembling after the error message
> prints and by adding the siglongjmp() function to imitate throwing an
> error. The goal was to maintain the same output as it was.
> 
> Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
> ---
>   disas/nanomips.cpp | 126 ++++++++++++++++++++++-----------------------
>   1 file changed, 61 insertions(+), 65 deletions(-)
> 
> diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
> index 5142f307fc..a8295ebfa8 100644
> --- a/disas/nanomips.cpp
> +++ b/disas/nanomips.cpp
> @@ -31,7 +31,6 @@
>   #include "disas/dis-asm.h"
>   
>   #include <string.h>
> -#include <stdexcept>
>   #include <stdio.h>
>   #include <stdarg.h>
>   
> @@ -134,10 +133,12 @@ static uint64 renumber_registers(uint64 index, uint64 *register_list,
>           return register_list[index];
>       }
>   
> -    throw std::runtime_error(img_format(
> -                   "Invalid register mapping index %" PRIu64
> -                   ", size of list = %zu",
> -                   index, register_list_size));
> +    g_autofree char *err = img_format(
> +                      "Invalid register mapping index %" PRIu64
> +                      ", size of list = %zu",
> +                      index, register_list_size);
> +    info->fprintf_func(info->stream, "%s", err);

There's no point passing the output of sprintf into fprintf like this.
Just fprintf in the first place.


> +                        disassembly_function dis_fn = table[i].disassembly;
> +                        if (dis_fn == 0) {
> +                            strcpy(dis,
> +                            "disassembler failure - bad table entry");
> +                            return -6;
> +                        }
> +                        type = table[i].type;
> +                        g_autofree char *dis_str = dis_fn(op_code, info);
> +                        strcpy(dis, dis_str);
> +                        return table[i].instructions_size;
> +                    } else {
> +                        strcpy(dis, "reserved instruction");
> +                        return -2;

Ought these errors use the same error path?


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 16/20] disas/nanomips: Replace exception handling
  2022-09-05 11:50   ` Richard Henderson
@ 2022-09-07 17:09     ` Milica Lazarevic
  0 siblings, 0 replies; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-07 17:09 UTC (permalink / raw)
  To: Richard Henderson, thuth@redhat.com
  Cc: qemu-devel@nongnu.org, cfontana@suse.de, berrange@redhat.com,
	pbonzini@redhat.com, vince.delvecchio@mediatek.com,
	peter.maydell@linaro.org, Djordje Todorovic, mips32r2@gmail.com,
	Dragan Mladjenovic

[-- Attachment #1: Type: text/plain, Size: 2534 bytes --]


On 9/5/22 10:55, Milica Lazarevic wrote:
> Since there's no support for exception handling in C, the try-catch
> blocks have been deleted, and throw clauses are replaced. When a runtime
> error happens, we're printing out the error message. Disassembling of
> the current instruction interrupts. This behavior is achieved by adding
> sigsetjmp() to discard further disassembling after the error message
> prints and by adding the siglongjmp() function to imitate throwing an
> error. The goal was to maintain the same output as it was.
>
> Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
> ---
>   disas/nanomips.cpp | 126 ++++++++++++++++++++++-----------------------
>   1 file changed, 61 insertions(+), 65 deletions(-)
>
> diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
> index 5142f307fc..a8295ebfa8 100644
> --- a/disas/nanomips.cpp
> +++ b/disas/nanomips.cpp
> @@ -31,7 +31,6 @@

> +                        disassembly_function dis_fn = table[i].disassembly;
> +                        if (dis_fn == 0) {
> +                            strcpy(dis,
> +                            "disassembler failure - bad table entry");
> +                            return -6;
> +                        }
> +                        type = table[i].type;
> +                        g_autofree char *dis_str = dis_fn(op_code, info);
> +                        strcpy(dis, dis_str);
> +                        return table[i].instructions_size;
> +                    } else {
> +                        strcpy(dis, "reserved instruction");
> +                        return -2;

Ought these errors use the same error path?


r~

I'm not sure if I understood the question correctly. The difference between these errors and the errors covered by the patch is that, in the case of the latter, the disassembling of one part of the instruction has already happened. For example, if we have an irregular GPR register index, the output of the assembler will look something like this:
...
0x80200622:  86ad 9018      Invalid GPR register index 33
...
On the other hand, if we have some error like "disassembler failure - bad table entry" - that string would be the only output regarding the instruction we're trying to disassemble. The disassembling process, in this case, hasn't begun, so there's no need for an interruption like in the previous example.

But yes, in both cases after printing the error message, the disassembling of the particular instruction is not continuing.

[-- Attachment #2: Type: text/html, Size: 5331 bytes --]

^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 17/20] disas/nanomips: Replace Cpp enums for C enums
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (15 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 16/20] disas/nanomips: Replace exception handling Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:47   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 18/20] disas/nanomips: Remove argument passing by ref Milica Lazarevic
                   ` (2 subsequent siblings)
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

Change enums to typedef enums to keep naming clear.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
---
 disas/nanomips.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index a8295ebfa8..f57d255de3 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -51,16 +51,16 @@ typedef bool (*conditional_function)(uint64 instruction);
 typedef char * (*disassembly_function)(uint64 instruction,
                                        struct Dis_info *info);
 
-enum TABLE_ENTRY_TYPE {
+typedef enum {
     instruction,
     call_instruction,
     branch_instruction,
     return_instruction,
     reserved_block,
     pool,
-};
+} TABLE_ENTRY_TYPE;
 
-enum TABLE_ATTRIBUTE_TYPE {
+typedef enum {
     MIPS64_    = 0x00000001,
     XNP_       = 0x00000002,
     XMMS_      = 0x00000004,
@@ -78,7 +78,7 @@ enum TABLE_ATTRIBUTE_TYPE {
     TLB_       = 0x00004000,
     MVH_       = 0x00008000,
     ALL_ATTRIBUTES = 0xffffffffull,
-};
+} TABLE_ATTRIBUTE_TYPE;
 
 struct Pool {
     TABLE_ENTRY_TYPE     type;
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 17/20] disas/nanomips: Replace Cpp enums for C enums
  2022-09-05  9:55 ` [PATCH v2 17/20] disas/nanomips: Replace Cpp enums for C enums Milica Lazarevic
@ 2022-09-05 11:47   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:47 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> Change enums to typedef enums to keep naming clear.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> Reviewed-by: Thomas Huth<thuth@redhat.com>
> ---
>   disas/nanomips.cpp | 8 ++++----
>   1 file changed, 4 insertions(+), 4 deletions(-)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 18/20] disas/nanomips: Remove argument passing by ref
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (16 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 17/20] disas/nanomips: Replace Cpp enums for C enums Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:56   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 19/20] disas/nanomips: Add struct keyword Milica Lazarevic
  2022-09-05  9:55 ` [PATCH v2 20/20] disas/nanomips: Rename nanomips.cpp to nanomips.c Milica Lazarevic
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

Replaced argument passing by reference with passing by address.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
---
 disas/nanomips.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index f57d255de3..ab54456c2e 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -635,7 +635,7 @@ static uint64 extract_op_code_value(const uint16 *data, int size)
  *      disassembly string  - on error will constain error string
  */
 static int Disassemble(const uint16 *data, char *dis,
-                       TABLE_ENTRY_TYPE & type, const Pool *table,
+                       TABLE_ENTRY_TYPE *type, const Pool *table,
                        int table_size, struct Dis_info *info)
 {
     for (int i = 0; i < table_size; i++) {
@@ -669,7 +669,7 @@ static int Disassemble(const uint16 *data, char *dis,
                             "disassembler failure - bad table entry");
                             return -6;
                         }
-                        type = table[i].type;
+                        *type = table[i].type;
                         g_autofree char *dis_str = dis_fn(op_code, info);
                         strcpy(dis, dis_str);
                         return table[i].instructions_size;
@@ -22248,7 +22248,7 @@ static int nanomips_dis(char *buf,
     uint16 bits[3] = {one, two, three};
 
     TABLE_ENTRY_TYPE type;
-    int size = Disassemble(bits, disasm, type, MAJOR, 2, info);
+    int size = Disassemble(bits, disasm, &type, MAJOR, 2, info);
 
     strcpy(buf, disasm);
     return size;
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 18/20] disas/nanomips: Remove argument passing by ref
  2022-09-05  9:55 ` [PATCH v2 18/20] disas/nanomips: Remove argument passing by ref Milica Lazarevic
@ 2022-09-05 11:56   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:56 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> Replaced argument passing by reference with passing by address.
> 
> Signed-off-by: Milica Lazarevic<milica.lazarevic@syrmia.com>
> Reviewed-by: Thomas Huth<thuth@redhat.com>
> ---
>   disas/nanomips.cpp | 6 +++---
>   1 file changed, 3 insertions(+), 3 deletions(-)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 19/20] disas/nanomips: Add struct keyword
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (17 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 18/20] disas/nanomips: Remove argument passing by ref Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:57   ` Richard Henderson
  2022-09-05  9:55 ` [PATCH v2 20/20] disas/nanomips: Rename nanomips.cpp to nanomips.c Milica Lazarevic
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

Changed the type of the table parameter in Disassemble function:
- from const Pool *
- to const struct Pool *

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
---
 disas/nanomips.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index ab54456c2e..7315484464 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -635,7 +635,7 @@ static uint64 extract_op_code_value(const uint16 *data, int size)
  *      disassembly string  - on error will constain error string
  */
 static int Disassemble(const uint16 *data, char *dis,
-                       TABLE_ENTRY_TYPE *type, const Pool *table,
+                       TABLE_ENTRY_TYPE *type, const struct Pool *table,
                        int table_size, struct Dis_info *info)
 {
     for (int i = 0; i < table_size; i++) {
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 19/20] disas/nanomips: Add struct keyword
  2022-09-05  9:55 ` [PATCH v2 19/20] disas/nanomips: Add struct keyword Milica Lazarevic
@ 2022-09-05 11:57   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:57 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> Changed the type of the table parameter in Disassemble function:
> - from const Pool *
> - to const struct Pool *
> 
> Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
> Reviewed-by: Thomas Huth <thuth@redhat.com>
> ---
>   disas/nanomips.cpp | 2 +-
>   1 file changed, 1 insertion(+), 1 deletion(-)
> 
> diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
> index ab54456c2e..7315484464 100644
> --- a/disas/nanomips.cpp
> +++ b/disas/nanomips.cpp
> @@ -635,7 +635,7 @@ static uint64 extract_op_code_value(const uint16 *data, int size)
>    *      disassembly string  - on error will constain error string
>    */
>   static int Disassemble(const uint16 *data, char *dis,
> -                       TABLE_ENTRY_TYPE *type, const Pool *table,
> +                       TABLE_ENTRY_TYPE *type, const struct Pool *table,
>                          int table_size, struct Dis_info *info)
>   {
>       for (int i = 0; i < table_size; i++) {

No, this means you're missing a typedef to comply with coding style.


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

* [PATCH v2 20/20] disas/nanomips: Rename nanomips.cpp to nanomips.c
  2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
                   ` (18 preceding siblings ...)
  2022-09-05  9:55 ` [PATCH v2 19/20] disas/nanomips: Add struct keyword Milica Lazarevic
@ 2022-09-05  9:55 ` Milica Lazarevic
  2022-09-05 11:59   ` Richard Henderson
  19 siblings, 1 reply; 46+ messages in thread
From: Milica Lazarevic @ 2022-09-05  9:55 UTC (permalink / raw)
  To: thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	richard.henderson, peter.maydell, djordje.todorovic, mips32r2,
	dragan.mladjenovic, Milica Lazarevic

Now that everything is converted to the C code, nanomips.cpp file is
renamed to "nanomips.c". Therefore, meson.build file is also changed.

The explicit cast after the call to g_malloc() is no longer needed
because the file now compiles as a C code.

Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
---
 disas/meson.build                  | 2 +-
 disas/{nanomips.cpp => nanomips.c} | 6 +-----
 2 files changed, 2 insertions(+), 6 deletions(-)
 rename disas/{nanomips.cpp => nanomips.c} (99%)

diff --git a/disas/meson.build b/disas/meson.build
index ba22f7cbcd..1977f5cd92 100644
--- a/disas/meson.build
+++ b/disas/meson.build
@@ -5,7 +5,7 @@ common_ss.add(when: 'CONFIG_HPPA_DIS', if_true: files('hppa.c'))
 common_ss.add(when: 'CONFIG_M68K_DIS', if_true: files('m68k.c'))
 common_ss.add(when: 'CONFIG_MICROBLAZE_DIS', if_true: files('microblaze.c'))
 common_ss.add(when: 'CONFIG_MIPS_DIS', if_true: files('mips.c'))
-common_ss.add(when: 'CONFIG_NANOMIPS_DIS', if_true: files('nanomips.cpp'))
+common_ss.add(when: 'CONFIG_NANOMIPS_DIS', if_true: files('nanomips.c'))
 common_ss.add(when: 'CONFIG_NIOS2_DIS', if_true: files('nios2.c'))
 common_ss.add(when: 'CONFIG_RISCV_DIS', if_true: files('riscv.c'))
 common_ss.add(when: 'CONFIG_SH4_DIS', if_true: files('sh4.c'))
diff --git a/disas/nanomips.cpp b/disas/nanomips.c
similarity index 99%
rename from disas/nanomips.cpp
rename to disas/nanomips.c
index 7315484464..afe9ae7cc2 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.c
@@ -525,11 +525,7 @@ static const char *GPR(uint64 reg, struct Dis_info *info)
 static char *save_restore_list(uint64 rt, uint64 count, uint64 gp,
                                struct Dis_info *info)
 {
-    /*
-     * Currently, this file compiles as a cpp file, so the explicit cast here
-     * is necessary. Later, the cast will be removed.
-     */
-    char *str = (char *)g_malloc(200);
+    char *str = g_malloc(200);
     str[0] = '\0';
 
     for (uint64 counter = 0; counter != count; counter++) {
-- 
2.25.1



^ permalink raw reply related	[flat|nested] 46+ messages in thread

* Re: [PATCH v2 20/20] disas/nanomips: Rename nanomips.cpp to nanomips.c
  2022-09-05  9:55 ` [PATCH v2 20/20] disas/nanomips: Rename nanomips.cpp to nanomips.c Milica Lazarevic
@ 2022-09-05 11:59   ` Richard Henderson
  0 siblings, 0 replies; 46+ messages in thread
From: Richard Henderson @ 2022-09-05 11:59 UTC (permalink / raw)
  To: Milica Lazarevic, thuth
  Cc: qemu-devel, cfontana, berrange, pbonzini, vince.delvecchio,
	peter.maydell, djordje.todorovic, mips32r2, dragan.mladjenovic

On 9/5/22 10:55, Milica Lazarevic wrote:
> Now that everything is converted to the C code, nanomips.cpp file is
> renamed to "nanomips.c". Therefore, meson.build file is also changed.
> 
> The explicit cast after the call to g_malloc() is no longer needed
> because the file now compiles as a C code.
> 
> Signed-off-by: Milica Lazarevic <milica.lazarevic@syrmia.com>
> ---
>   disas/meson.build                  | 2 +-
>   disas/{nanomips.cpp => nanomips.c} | 6 +-----
>   2 files changed, 2 insertions(+), 6 deletions(-)
>   rename disas/{nanomips.cpp => nanomips.c} (99%)

Reviewed-by: Richard Henderson <richard.henderson@linaro.org>

> @@ -525,11 +525,7 @@ static const char *GPR(uint64 reg, struct Dis_info *info)
>   static char *save_restore_list(uint64 rt, uint64 count, uint64 gp,
>                                  struct Dis_info *info)
>   {
> -    /*
> -     * Currently, this file compiles as a cpp file, so the explicit cast here
> -     * is necessary. Later, the cast will be removed.
> -     */
> -    char *str = (char *)g_malloc(200);
> +    char *str = g_malloc(200);

... noting that this change is obviated by the use of g_strjoinv.


r~


^ permalink raw reply	[flat|nested] 46+ messages in thread

end of thread, other threads:[~2022-09-08 21:50 UTC | newest]

Thread overview: 46+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2022-09-05  9:55 [PATCH v2 0/20] Convert nanoMIPS disassembler from C++ to C Milica Lazarevic
2022-09-05  9:55 ` [PATCH v2 01/20] disas/nanomips: Remove namespace img Milica Lazarevic
2022-09-05 11:00   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 02/20] disas/nanomips: Extract enums out of the NMD class Milica Lazarevic
2022-09-05 11:00   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 03/20] disas/nanomips: Delete NMD class fields Milica Lazarevic
2022-09-05 11:04   ` Richard Henderson
2022-09-05 11:53     ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 04/20] disas/nanomips: Remove helper methods from class Milica Lazarevic
2022-09-05 11:05   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 05/20] disas/nanomips: Remove __cond " Milica Lazarevic
2022-09-05 11:06   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 06/20] disas/nanomips: Remove disasm " Milica Lazarevic
2022-09-05 11:08   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 07/20] disas/nanomips: Remove Pool tables from the class Milica Lazarevic
2022-09-05 11:11   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 08/20] disas/nanomips: Remove NMD class Milica Lazarevic
2022-09-05 11:13   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 09/20] disas/nanomips: Move typedefs etc to nanomips.cpp Milica Lazarevic
2022-09-05 11:14   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 10/20] disas/nanomips: Delete nanomips.h Milica Lazarevic
2022-09-05 11:14   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 11/20] disas/nanomips: Remove #inlcude <sstream> Milica Lazarevic
2022-09-05 11:14   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 12/20] disas/nanomips: Replace std::string type Milica Lazarevic
2022-09-05 11:32   ` Richard Henderson
2022-09-08 19:16     ` Milica Lazarevic
2022-09-08 21:14       ` Richard Henderson
2022-09-08 21:46         ` Milica Lazarevic
2022-09-05  9:55 ` [PATCH v2 13/20] disas/nanomips: Prevent memory leaking Milica Lazarevic
2022-09-05 11:41   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 14/20] disas/nanomips: Remove function overloading Milica Lazarevic
2022-09-05 11:43   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 15/20] disas/nanomips: Introduce Dis_info struct Milica Lazarevic
2022-09-05 11:55   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 16/20] disas/nanomips: Replace exception handling Milica Lazarevic
2022-09-05 11:50   ` Richard Henderson
2022-09-07 17:09     ` Milica Lazarevic
2022-09-05  9:55 ` [PATCH v2 17/20] disas/nanomips: Replace Cpp enums for C enums Milica Lazarevic
2022-09-05 11:47   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 18/20] disas/nanomips: Remove argument passing by ref Milica Lazarevic
2022-09-05 11:56   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 19/20] disas/nanomips: Add struct keyword Milica Lazarevic
2022-09-05 11:57   ` Richard Henderson
2022-09-05  9:55 ` [PATCH v2 20/20] disas/nanomips: Rename nanomips.cpp to nanomips.c Milica Lazarevic
2022-09-05 11:59   ` Richard Henderson

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).