diff --git a/disas/nanomips.cpp b/disas/nanomips.cpp
index 561e4ff095..551bcb3164 100644
--- a/disas/nanomips.cpp
+++ b/disas/nanomips.cpp
@@ -526,7 +526,9 @@ static const 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)));
+        const char *dis_str = img_format(",%s", GPR(this_rt));
+        strcat(str, dis_str);
+        free((char *)dis_str);
     }
 
     return strdup(str);
@@ -663,7 +665,9 @@ static int Disassemble(const uint16 *data, char *dis,
                                 return -6;
                             }
                             type = table[i].type;
-                            strcpy(dis, dis_fn(op_code));
+                            const char *dis_str = dis_fn(op_code);
+                            strcpy(dis, dis_str);
+                            free((char *)dis_str);
                             return table[i].instructions_size;
                         } else {
                             strcpy(dis, "reserved instruction");
@@ -1737,7 +1741,10 @@ static const char *ACLR(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("ACLR %s, %s(%s)", bit, s, rs);
+    const char *ret = img_format("ACLR %s, %s(%s)", bit, s, rs);
+    free((char *)bit);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -1833,7 +1840,9 @@ static const char *ADDIU_32_(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("ADDIU %s, %s, %s", rt, rs, u);
+    const char *ret = img_format("ADDIU %s, %s, %s", rt, rs, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -1853,8 +1862,9 @@ static const char *ADDIU_48_(uint64 instruction)
 
     const char *rt = GPR(copy(rt_value));
     const char *s = IMMEDIATE(copy(s_value));
-
-    return img_format("ADDIU %s, %s", rt, s);
+    const char *ret = img_format("ADDIU %s, %s", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -1874,8 +1884,9 @@ static const char *ADDIU_GP48_(uint64 instruction)
 
     const char *rt = GPR(copy(rt_value));
     const char *s = IMMEDIATE(copy(s_value));
-
-    return img_format("ADDIU %s, $%d, %s", rt, 28, s);
+    const char *ret = img_format("ADDIU %s, $%d, %s", rt, 28, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -1896,7 +1907,9 @@ static const char *ADDIU_GP_B_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("ADDIU %s, $%d, %s", rt, 28, u);
+    const char *ret = img_format("ADDIU %s, $%d, %s", rt, 28, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -1917,7 +1930,9 @@ static const char *ADDIU_GP_W_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("ADDIU %s, $%d, %s", rt, 28, u);
+    const char *ret = img_format("ADDIU %s, $%d, %s", rt, 28, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -1940,7 +1955,9 @@ static const char *ADDIU_NEG_(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *u = IMMEDIATE(neg_copy(u_value));
 
-    return img_format("ADDIU %s, %s, %s", rt, rs, u);
+    const char *ret = img_format("ADDIU %s, %s, %s", rt, rs, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -1961,7 +1978,9 @@ static const char *ADDIU_R1_SP_(uint64 instruction)
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("ADDIU %s, $%d, %s", rt3, 29, u);
+    const char *ret = img_format("ADDIU %s, $%d, %s", rt3, 29, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -1984,7 +2003,9 @@ static const char *ADDIU_R2_(uint64 instruction)
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("ADDIU %s, %s, %s", rt3, rs3, u);
+    const char *ret = img_format("ADDIU %s, %s, %s", rt3, rs3, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -2004,7 +2025,9 @@ static const char *ADDIU_RS5_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = IMMEDIATE(copy(s_value));
 
-    return img_format("ADDIU %s, %s", rt, s);
+    const char *ret = img_format("ADDIU %s, %s", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2026,7 +2049,9 @@ static const char *ADDIUPC_32_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("ADDIUPC %s, %s", rt, s);
+    const char *ret = img_format("ADDIUPC %s, %s", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2048,7 +2073,9 @@ static const char *ADDIUPC_48_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 6);
 
-    return img_format("ADDIUPC %s, %s", rt, s);
+    const char *ret = img_format("ADDIUPC %s, %s", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2506,7 +2533,9 @@ static const char *ALUIPC(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
+    const char *ret = img_format("ALUIPC %s, %%pcrel_hi(%s)", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2574,7 +2603,9 @@ static const char *ANDI_16_(uint64 instruction)
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
     const char *eu = IMMEDIATE(encode_eu_from_u_andi16(eu_value));
 
-    return img_format("ANDI %s, %s, %s", rt3, rs3, eu);
+    const char *ret = img_format("ANDI %s, %s, %s", rt3, rs3, eu);
+    free((char *)eu);
+    return ret;
 }
 
 
@@ -2598,7 +2629,9 @@ static const char *ANDI_32_(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("ANDI %s, %s, %s", rt, rs, u);
+    const char *ret = img_format("ANDI %s, %s, %s", rt, rs, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -2622,7 +2655,9 @@ static const char *APPEND(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("APPEND %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("APPEND %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -2646,7 +2681,10 @@ static const char *ASET(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("ASET %s, %s(%s)", bit, s, rs);
+    const char *ret = img_format("ASET %s, %s(%s)", bit, s, rs);
+    free((char *)bit);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2666,7 +2704,9 @@ static const char *BALC_16_(uint64 instruction)
 
     const char *s = ADDRESS(encode_s_from_address(s_value), 2);
 
-    return img_format("BALC %s", s);
+    const char *ret = img_format("BALC %s", s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2686,7 +2726,9 @@ static const char *BALC_32_(uint64 instruction)
 
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BALC %s", s);
+    const char *ret = img_format("BALC %s", s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2732,7 +2774,10 @@ static const char *BBEQZC(uint64 instruction)
     const char *bit = IMMEDIATE(copy(bit_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BBEQZC %s, %s, %s", rt, bit, s);
+    const char *ret = img_format("BBEQZC %s, %s, %s", rt, bit, s);
+    free((char *)bit);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2756,7 +2801,10 @@ static const char *BBNEZC(uint64 instruction)
     const char *bit = IMMEDIATE(copy(bit_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BBNEZC %s, %s, %s", rt, bit, s);
+    const char *ret = img_format("BBNEZC %s, %s, %s", rt, bit, s);
+    free((char *)bit);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2776,7 +2824,9 @@ static const char *BC_16_(uint64 instruction)
 
     const char *s = ADDRESS(encode_s_from_address(s_value), 2);
 
-    return img_format("BC %s", s);
+    const char *ret = img_format("BC %s", s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2796,7 +2846,9 @@ static const char *BC_32_(uint64 instruction)
 
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BC %s", s);
+    const char *ret = img_format("BC %s", s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2818,7 +2870,9 @@ static const char *BC1EQZC(uint64 instruction)
     const char *ft = FPR(copy(ft_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BC1EQZC %s, %s", ft, s);
+    const char *ret = img_format("BC1EQZC %s, %s", ft, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2840,7 +2894,9 @@ static const char *BC1NEZC(uint64 instruction)
     const char *ft = FPR(copy(ft_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BC1NEZC %s, %s", ft, s);
+    const char *ret = img_format("BC1NEZC %s, %s", ft, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2862,7 +2918,9 @@ static const char *BC2EQZC(uint64 instruction)
     const char *ct = CPR(copy(ct_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BC2EQZC %s, %s", ct, s);
+    const char *ret = img_format("BC2EQZC %s, %s", ct, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2884,7 +2942,9 @@ static const char *BC2NEZC(uint64 instruction)
     const char *ct = CPR(copy(ct_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BC2NEZC %s, %s", ct, s);
+    const char *ret = img_format("BC2NEZC %s, %s", ct, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2908,7 +2968,9 @@ static const char *BEQC_16_(uint64 instruction)
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *u = ADDRESS(encode_u_from_address(u_value), 2);
 
-    return img_format("BEQC %s, %s, %s", rs3, rt3, u);
+    const char *ret = img_format("BEQC %s, %s, %s", rs3, rt3, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -2932,7 +2994,9 @@ static const char *BEQC_32_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BEQC %s, %s, %s", rs, rt, s);
+    const char *ret = img_format("BEQC %s, %s, %s", rs, rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2956,7 +3020,10 @@ static const char *BEQIC(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BEQIC %s, %s, %s", rt, u, s);
+    const char *ret = img_format("BEQIC %s, %s, %s", rt, u, s);
+    free((char *)u);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -2978,7 +3045,9 @@ static const char *BEQZC_16_(uint64 instruction)
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 2);
 
-    return img_format("BEQZC %s, %s", rt3, s);
+    const char *ret = img_format("BEQZC %s, %s", rt3, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3002,7 +3071,9 @@ static const char *BGEC(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BGEC %s, %s, %s", rs, rt, s);
+    const char *ret = img_format("BGEC %s, %s, %s", rs, rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3026,7 +3097,10 @@ static const char *BGEIC(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BGEIC %s, %s, %s", rt, u, s);
+    const char *ret = img_format("BGEIC %s, %s, %s", rt, u, s);
+    free((char *)u);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3050,7 +3124,10 @@ static const char *BGEIUC(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BGEIUC %s, %s, %s", rt, u, s);
+    const char *ret = img_format("BGEIUC %s, %s, %s", rt, u, s);
+    free((char *)u);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3074,7 +3151,9 @@ static const char *BGEUC(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BGEUC %s, %s, %s", rs, rt, s);
+    const char *ret = img_format("BGEUC %s, %s, %s", rs, rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3098,7 +3177,9 @@ static const char *BLTC(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BLTC %s, %s, %s", rs, rt, s);
+    const char *ret = img_format("BLTC %s, %s, %s", rs, rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3122,7 +3203,10 @@ static const char *BLTIC(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BLTIC %s, %s, %s", rt, u, s);
+    const char *ret = img_format("BLTIC %s, %s, %s", rt, u, s);
+    free((char *)u);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3146,7 +3230,10 @@ static const char *BLTIUC(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BLTIUC %s, %s, %s", rt, u, s);
+    const char *ret = img_format("BLTIUC %s, %s, %s", rt, u, s);
+    free((char *)u);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3170,7 +3257,9 @@ static const char *BLTUC(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BLTUC %s, %s, %s", rs, rt, s);
+    const char *ret = img_format("BLTUC %s, %s, %s", rs, rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3194,7 +3283,9 @@ static const char *BNEC_16_(uint64 instruction)
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *u = ADDRESS(encode_u_from_address(u_value), 2);
 
-    return img_format("BNEC %s, %s, %s", rs3, rt3, u);
+    const char *ret = img_format("BNEC %s, %s, %s", rs3, rt3, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -3218,7 +3309,9 @@ static const char *BNEC_32_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BNEC %s, %s, %s", rs, rt, s);
+    const char *ret = img_format("BNEC %s, %s, %s", rs, rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3242,7 +3335,10 @@ static const char *BNEIC(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BNEIC %s, %s, %s", rt, u, s);
+    const char *ret = img_format("BNEIC %s, %s, %s", rt, u, s);
+    free((char *)u);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3264,7 +3360,9 @@ static const char *BNEZC_16_(uint64 instruction)
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 2);
 
-    return img_format("BNEZC %s, %s", rt3, s);
+    const char *ret = img_format("BNEZC %s, %s", rt3, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3284,7 +3382,9 @@ static const char *BPOSGE32C(uint64 instruction)
 
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("BPOSGE32C %s", s);
+    const char *ret = img_format("BPOSGE32C %s", s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3304,7 +3404,9 @@ static const char *BREAK_16_(uint64 instruction)
 
     const char *code = IMMEDIATE(copy(code_value));
 
-    return img_format("BREAK %s", code);
+    const char *ret = img_format("BREAK %s", code);
+    free((char *)code);
+    return ret;
 }
 
 
@@ -3324,7 +3426,9 @@ static const char *BREAK_32_(uint64 instruction)
 
     const char *code = IMMEDIATE(copy(code_value));
 
-    return img_format("BREAK %s", code);
+    const char *ret = img_format("BREAK %s", code);
+    free((char *)code);
+    return ret;
 }
 
 
@@ -3368,7 +3472,10 @@ static const char *CACHE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("CACHE %s, %s(%s)", op, s, rs);
+    const char *ret = img_format("CACHE %s, %s(%s)", op, s, rs);
+    free((char *)op);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -3392,7 +3499,10 @@ static const char *CACHEE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("CACHEE %s, %s(%s)", op, s, rs);
+    const char *ret = img_format("CACHEE %s, %s(%s)", op, s, rs);
+    free((char *)op);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -4967,7 +5077,9 @@ static const char *COP2_1(uint64 instruction)
 
     const char *cofun = IMMEDIATE(copy(cofun_value));
 
-    return img_format("COP2_1 %s", cofun);
+    const char *ret = img_format("COP2_1 %s", cofun);
+    free((char *)cofun);
+    return ret;
 }
 
 
@@ -5297,7 +5409,9 @@ static const char *DADDIU_48_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = IMMEDIATE(copy(s_value));
 
-    return img_format("DADDIU %s, %s", rt, s);
+    const char *ret = img_format("DADDIU %s, %s", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -5321,7 +5435,9 @@ static const char *DADDIU_NEG_(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *u = IMMEDIATE(neg_copy(u_value));
 
-    return img_format("DADDIU %s, %s, %s", rt, rs, u);
+    const char *ret = img_format("DADDIU %s, %s, %s", rt, rs, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -5345,7 +5461,9 @@ static const char *DADDIU_U12_(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("DADDIU %s, %s, %s", rt, rs, u);
+    const char *ret = img_format("DADDIU %s, %s, %s", rt, rs, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -5503,7 +5621,7 @@ static const char *DERET(uint64 instruction)
 {
     (void)instruction;
 
-    return "DERET ";
+    return strdup("DERET ");
 }
 
 
@@ -5529,7 +5647,10 @@ static const char *DEXTM(uint64 instruction)
     const char *lsb = IMMEDIATE(copy(lsb_value));
     const char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
-    return img_format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
+    const char *ret = img_format("DEXTM %s, %s, %s, %s", rt, rs, lsb, msbd);
+    free((char *)lsb);
+    free((char *)msbd);
+    return ret;
 }
 
 
@@ -5555,7 +5676,10 @@ static const char *DEXT(uint64 instruction)
     const char *lsb = IMMEDIATE(copy(lsb_value));
     const char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
-    return img_format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
+    const char *ret = img_format("DEXT %s, %s, %s, %s", rt, rs, lsb, msbd);
+    free((char *)lsb);
+    free((char *)msbd);
+    return ret;
 }
 
 
@@ -5581,7 +5705,10 @@ static const char *DEXTU(uint64 instruction)
     const char *lsb = IMMEDIATE(copy(lsb_value));
     const char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
-    return img_format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
+    const char *ret = img_format("DEXTU %s, %s, %s, %s", rt, rs, lsb, msbd);
+    free((char *)lsb);
+    free((char *)msbd);
+    return ret;
 }
 
 
@@ -5608,8 +5735,11 @@ static const char *DINSM(uint64 instruction)
     const 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);
+    const char *ret = img_format("DINSM %s, %s, %s, %s", rt, rs, pos, size);
     /* hand edited */
+    free((char *)pos);
+    free((char *)size);
+    return ret;
 }
 
 
@@ -5636,8 +5766,11 @@ static const char *DINS(uint64 instruction)
     const 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);
+    const char *ret = img_format("DINS %s, %s, %s, %s", rt, rs, pos, size);
     /* hand edited */
+    free((char *)pos);
+    free((char *)size);
+    return ret;
 }
 
 
@@ -5664,8 +5797,11 @@ static const char *DINSU(uint64 instruction)
     const 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);
+    const char *ret = img_format("DINSU %s, %s, %s, %s", rt, rs, pos, size);
     /* hand edited */
+    free((char *)pos);
+    free((char *)size);
+    return ret;
 }
 
 
@@ -5807,7 +5943,9 @@ static const char *DLSA(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u2 = IMMEDIATE(copy(u2_value));
 
-    return img_format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
+    const char *ret = img_format("DLSA %s, %s, %s, %s", rd, rs, rt, u2);
+    free((char *)u2);
+    return ret;
 }
 
 
@@ -5829,7 +5967,9 @@ static const char *DLUI_48_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("DLUI %s, %s", rt, u);
+    const char *ret = img_format("DLUI %s, %s", rt, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -5853,7 +5993,9 @@ static const char *DMFC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("DMFC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("DMFC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -5921,7 +6063,9 @@ static const char *DMFGC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("DMFGC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("DMFGC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -5993,7 +6137,9 @@ static const char *DMTC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("DMTC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("DMTC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -6061,7 +6207,9 @@ static const char *DMTGC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("DMTGC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("DMTGC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -6586,7 +6734,9 @@ static const char *DROTR(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("DROTR %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("DROTR %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -6610,7 +6760,9 @@ static const char *DROTR32(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("DROTR32 %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("DROTR32 %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -6660,7 +6812,10 @@ static const char *DROTX(uint64 instruction)
     const char *shift = IMMEDIATE(copy(shift_value));
     const char *shiftx = IMMEDIATE(copy(shiftx_value));
 
-    return img_format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
+    const char *ret = img_format("DROTX %s, %s, %s, %s", rt, rs, shift, shiftx);
+    free((char *)shift);
+    free((char *)shiftx);
+    return ret;
 }
 
 
@@ -6684,7 +6839,9 @@ static const char *DSLL(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("DSLL %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("DSLL %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -6708,7 +6865,9 @@ static const char *DSLL32(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("DSLL32 %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("DSLL32 %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -6756,7 +6915,9 @@ static const char *DSRA(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("DSRA %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("DSRA %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -6780,7 +6941,9 @@ static const char *DSRA32(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("DSRA32 %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("DSRA32 %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -6828,7 +6991,9 @@ static const char *DSRL(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("DSRL %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("DSRL %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -6852,7 +7017,9 @@ static const char *DSRL32(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("DSRL32 %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("DSRL32 %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -6982,7 +7149,7 @@ static const char *EHB(uint64 instruction)
 {
     (void)instruction;
 
-    return "EHB ";
+    return strdup("EHB ");
 }
 
 
@@ -7040,7 +7207,7 @@ static const char *ERET(uint64 instruction)
 {
     (void)instruction;
 
-    return "ERET ";
+    return strdup("ERET ");
 }
 
 
@@ -7058,7 +7225,7 @@ static const char *ERETNC(uint64 instruction)
 {
     (void)instruction;
 
-    return "ERETNC ";
+    return strdup("ERETNC ");
 }
 
 
@@ -7124,7 +7291,10 @@ static const char *EXT(uint64 instruction)
     const char *lsb = IMMEDIATE(copy(lsb_value));
     const char *msbd = IMMEDIATE(encode_msbd_from_size(msbd_value));
 
-    return img_format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
+    const char *ret = img_format("EXT %s, %s, %s, %s", rt, rs, lsb, msbd);
+    free((char *)lsb);
+    free((char *)msbd);
+    return ret;
 }
 
 
@@ -7150,7 +7320,9 @@ static const char *EXTD(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
+    const char *ret = img_format("EXTD %s, %s, %s, %s", rd, rs, rt, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -7176,7 +7348,9 @@ static const char *EXTD32(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
+    const char *ret = img_format("EXTD32 %s, %s, %s, %s", rd, rs, rt, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -7200,7 +7374,9 @@ static const char *EXTPDP(uint64 instruction)
     const char *ac = AC(copy(ac_value));
     const char *size = IMMEDIATE(copy(size_value));
 
-    return img_format("EXTPDP %s, %s, %s", rt, ac, size);
+    const char *ret = img_format("EXTPDP %s, %s, %s", rt, ac, size);
+    free((char *)size);
+    return ret;
 }
 
 
@@ -7248,7 +7424,9 @@ static const char *EXTP(uint64 instruction)
     const char *ac = AC(copy(ac_value));
     const char *size = IMMEDIATE(copy(size_value));
 
-    return img_format("EXTP %s, %s, %s", rt, ac, size);
+    const char *ret = img_format("EXTP %s, %s, %s", rt, ac, size);
+    free((char *)size);
+    return ret;
 }
 
 
@@ -7297,7 +7475,9 @@ static const char *EXTR_RS_W(uint64 instruction)
     const char *ac = AC(copy(ac_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
+    const char *ret = img_format("EXTR_RS.W %s, %s, %s", rt, ac, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -7322,7 +7502,9 @@ static const char *EXTR_R_W(uint64 instruction)
     const char *ac = AC(copy(ac_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("EXTR_R.W %s, %s, %s", rt, ac, shift);
+    const char *ret = img_format("EXTR_R.W %s, %s, %s", rt, ac, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -7347,7 +7529,9 @@ static const char *EXTR_S_H(uint64 instruction)
     const char *ac = AC(copy(ac_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("EXTR_S.H %s, %s, %s", rt, ac, shift);
+    const char *ret = img_format("EXTR_S.H %s, %s, %s", rt, ac, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -7372,7 +7556,9 @@ static const char *EXTR_W(uint64 instruction)
     const char *ac = AC(copy(ac_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("EXTR.W %s, %s, %s", rt, ac, shift);
+    const char *ret = img_format("EXTR.W %s, %s, %s", rt, ac, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -7499,7 +7685,9 @@ static const char *EXTW(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
+    const char *ret = img_format("EXTW %s, %s, %s, %s", rd, rs, rt, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -7631,7 +7819,9 @@ static const char *HYPCALL(uint64 instruction)
 
     const char *code = IMMEDIATE(copy(code_value));
 
-    return img_format("HYPCALL %s", code);
+    const char *ret = img_format("HYPCALL %s", code);
+    free((char *)code);
+    return ret;
 }
 
 
@@ -7651,7 +7841,9 @@ static const char *HYPCALL_16_(uint64 instruction)
 
     const char *code = IMMEDIATE(copy(code_value));
 
-    return img_format("HYPCALL %s", code);
+    const char *ret = img_format("HYPCALL %s", code);
+    free((char *)code);
+    return ret;
 }
 
 
@@ -7678,8 +7870,11 @@ static const char *INS(uint64 instruction)
     const 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);
+    const char *ret = img_format("INS %s, %s, %s, %s", rt, rs, pos, size);
     /* hand edited */
+    free((char *)pos);
+    free((char *)size);
+    return ret;
 }
 
 
@@ -7718,7 +7913,7 @@ static const char *IRET(uint64 instruction)
 {
     (void)instruction;
 
-    return "IRET ";
+    return strdup("IRET ");
 }
 
 
@@ -7826,7 +8021,9 @@ static const char *LB_16_(uint64 instruction)
     const 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);
+    const char *ret = img_format("LB %s, %s(%s)", rt3, u, rs3);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -7848,7 +8045,9 @@ static const char *LB_GP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("LB %s, %s($%d)", rt, u, 28);
+    const char *ret = img_format("LB %s, %s($%d)", rt, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -7872,7 +8071,9 @@ static const char *LB_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LB %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LB %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -7896,7 +8097,9 @@ static const char *LB_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LB %s, %s(%s)", rt, u, rs);
+    const char *ret = img_format("LB %s, %s(%s)", rt, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -7920,7 +8123,9 @@ static const char *LBE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LBE %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LBE %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -7944,7 +8149,9 @@ static const char *LBU_16_(uint64 instruction)
     const 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);
+    const char *ret = img_format("LBU %s, %s(%s)", rt3, u, rs3);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -7966,7 +8173,9 @@ static const char *LBU_GP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("LBU %s, %s($%d)", rt, u, 28);
+    const char *ret = img_format("LBU %s, %s($%d)", rt, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -7990,7 +8199,9 @@ static const char *LBU_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LBU %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LBU %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8014,7 +8225,9 @@ static const char *LBU_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LBU %s, %s(%s)", rt, u, rs);
+    const char *ret = img_format("LBU %s, %s(%s)", rt, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -8038,7 +8251,9 @@ static const char *LBUE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LBUE %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LBUE %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8108,7 +8323,9 @@ static const char *LD_GP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("LD %s, %s($%d)", rt, u, 28);
+    const char *ret = img_format("LD %s, %s($%d)", rt, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -8132,7 +8349,9 @@ static const char *LD_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LD %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LD %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8156,7 +8375,9 @@ static const char *LD_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LD %s, %s(%s)", rt, u, rs);
+    const char *ret = img_format("LD %s, %s(%s)", rt, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -8178,7 +8399,9 @@ static const char *LDC1_GP_(uint64 instruction)
     const char *ft = FPR(copy(ft_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("LDC1 %s, %s($%d)", ft, u, 28);
+    const char *ret = img_format("LDC1 %s, %s($%d)", ft, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -8202,7 +8425,9 @@ static const char *LDC1_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LDC1 %s, %s(%s)", ft, s, rs);
+    const char *ret = img_format("LDC1 %s, %s(%s)", ft, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8226,7 +8451,9 @@ static const char *LDC1_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LDC1 %s, %s(%s)", ft, u, rs);
+    const char *ret = img_format("LDC1 %s, %s(%s)", ft, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -8298,7 +8525,9 @@ static const char *LDC2(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LDC2 %s, %s(%s)", ct, s, rs);
+    const char *ret = img_format("LDC2 %s, %s(%s)", ct, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8324,7 +8553,10 @@ static const char *LDM(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img_format("LDM %s, %s(%s), %s", rt, s, rs, count3);
+    const char *ret = img_format("LDM %s, %s(%s), %s", rt, s, rs, count3);
+    free((char *)s);
+    free((char *)count3);
+    return ret;
 }
 
 
@@ -8346,7 +8578,9 @@ static const char *LDPC_48_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 6);
 
-    return img_format("LDPC %s, %s", rt, s);
+    const char *ret = img_format("LDPC %s, %s", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8418,7 +8652,9 @@ static const char *LH_16_(uint64 instruction)
     const 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);
+    const char *ret = img_format("LH %s, %s(%s)", rt3, u, rs3);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -8440,7 +8676,9 @@ static const char *LH_GP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("LH %s, %s($%d)", rt, u, 28);
+    const char *ret = img_format("LH %s, %s($%d)", rt, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -8464,7 +8702,9 @@ static const char *LH_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LH %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LH %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8488,7 +8728,9 @@ static const char *LH_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LH %s, %s(%s)", rt, u, rs);
+    const char *ret = img_format("LH %s, %s(%s)", rt, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -8512,7 +8754,9 @@ static const char *LHE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LHE %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LHE %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8536,7 +8780,9 @@ static const char *LHU_16_(uint64 instruction)
     const 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);
+    const char *ret = img_format("LHU %s, %s(%s)", rt3, u, rs3);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -8558,7 +8804,9 @@ static const char *LHU_GP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("LHU %s, %s($%d)", rt, u, 28);
+    const char *ret = img_format("LHU %s, %s($%d)", rt, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -8582,7 +8830,9 @@ static const char *LHU_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LHU %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LHU %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8606,7 +8856,9 @@ static const char *LHU_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LHU %s, %s(%s)", rt, u, rs);
+    const char *ret = img_format("LHU %s, %s(%s)", rt, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -8630,7 +8882,9 @@ static const char *LHUE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LHUE %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LHUE %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8748,7 +9002,9 @@ static const char *LI_16_(uint64 instruction)
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *eu = IMMEDIATE(encode_eu_from_s_li16(eu_value));
 
-    return img_format("LI %s, %s", rt3, eu);
+    const char *ret = img_format("LI %s, %s", rt3, eu);
+    free((char *)eu);
+    return ret;
 }
 
 
@@ -8770,7 +9026,9 @@ static const char *LI_48_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = IMMEDIATE(copy(s_value));
 
-    return img_format("LI %s, %s", rt, s);
+    const char *ret = img_format("LI %s, %s", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8794,7 +9052,9 @@ static const char *LL(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LL %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LL %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8818,7 +9078,9 @@ static const char *LLD(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LLD %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LLD %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8866,7 +9128,9 @@ static const char *LLE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LLE %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LLE %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8940,7 +9204,9 @@ static const char *LSA(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u2 = IMMEDIATE(copy(u2_value));
 
-    return img_format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
+    const char *ret = img_format("LSA %s, %s, %s, %s", rd, rs, rt, u2);
+    free((char *)u2);
+    return ret;
 }
 
 
@@ -8962,7 +9228,9 @@ static const char *LUI(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = IMMEDIATE(copy(s_value));
 
-    return img_format("LUI %s, %%hi(%s)", rt, s);
+    const char *ret = img_format("LUI %s, %%hi(%s)", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -8986,7 +9254,9 @@ static const char *LW_16_(uint64 instruction)
     const 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);
+    const char *ret = img_format("LW %s, %s(%s)", rt3, u, rs3);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -9010,7 +9280,9 @@ static const char *LW_4X4_(uint64 instruction)
     const 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);
+    const char *ret = img_format("LW %s, %s(%s)", rt4, u, rs4);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -9032,7 +9304,9 @@ static const char *LW_GP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("LW %s, %s($%d)", rt, u, 28);
+    const char *ret = img_format("LW %s, %s($%d)", rt, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -9054,7 +9328,9 @@ static const char *LW_GP16_(uint64 instruction)
     const char *rt3 = GPR(decode_gpr_gpr3(rt3_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("LW %s, %s($%d)", rt3, u, 28);
+    const char *ret = img_format("LW %s, %s($%d)", rt3, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -9078,7 +9354,9 @@ static const char *LW_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LW %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LW %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -9100,7 +9378,9 @@ static const char *LW_SP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("LW %s, %s($%d)", rt, u, 29);
+    const char *ret = img_format("LW %s, %s($%d)", rt, u, 29);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -9124,7 +9404,9 @@ static const char *LW_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LW %s, %s(%s)", rt, u, rs);
+    const char *ret = img_format("LW %s, %s(%s)", rt, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -9146,7 +9428,9 @@ static const char *LWC1_GP_(uint64 instruction)
     const char *ft = FPR(copy(ft_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("LWC1 %s, %s($%d)", ft, u, 28);
+    const char *ret = img_format("LWC1 %s, %s($%d)", ft, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -9170,7 +9454,9 @@ static const char *LWC1_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LWC1 %s, %s(%s)", ft, s, rs);
+    const char *ret = img_format("LWC1 %s, %s(%s)", ft, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -9194,7 +9480,9 @@ static const char *LWC1_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LWC1 %s, %s(%s)", ft, u, rs);
+    const char *ret = img_format("LWC1 %s, %s(%s)", ft, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -9266,7 +9554,9 @@ static const char *LWC2(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LWC2 %s, %s(%s)", ct, s, rs);
+    const char *ret = img_format("LWC2 %s, %s(%s)", ct, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -9290,7 +9580,9 @@ static const char *LWE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LWE %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LWE %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -9316,7 +9608,10 @@ static const char *LWM(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img_format("LWM %s, %s(%s), %s", rt, s, rs, count3);
+    const char *ret = img_format("LWM %s, %s(%s), %s", rt, s, rs, count3);
+    free((char *)s);
+    free((char *)count3);
+    return ret;
 }
 
 
@@ -9338,7 +9633,9 @@ static const char *LWPC_48_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 6);
 
-    return img_format("LWPC %s, %s", rt, s);
+    const char *ret = img_format("LWPC %s, %s", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -9360,7 +9657,9 @@ static const char *LWU_GP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("LWU %s, %s($%d)", rt, u, 28);
+    const char *ret = img_format("LWU %s, %s($%d)", rt, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -9384,7 +9683,9 @@ static const char *LWU_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LWU %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("LWU %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -9408,7 +9709,9 @@ static const char *LWU_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("LWU %s, %s(%s)", rt, u, rs);
+    const char *ret = img_format("LWU %s, %s(%s)", rt, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -9504,7 +9807,9 @@ static const char *LWXS_16_(uint64 instruction)
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
     const char *rt3 = IMMEDIATE(decode_gpr_gpr3(rt3_value));
 
-    return img_format("LWXS %s, %s(%s)", rd3, rs3, rt3);
+    const char *ret = img_format("LWXS %s, %s(%s)", rd3, rs3, rt3);
+    free((char *)rt3);
+    return ret;
 }
 
 
@@ -9846,7 +10151,10 @@ static const char *MFC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MFC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("MFC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)c0s);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -9914,7 +10222,10 @@ static const char *MFGC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MFGC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("MFGC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)c0s);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -9938,7 +10249,10 @@ static const char *MFHC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MFHC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("MFHC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)c0s);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -10006,7 +10320,10 @@ static const char *MFHGC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MFHGC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("MFHGC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)c0s);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -10053,7 +10370,11 @@ static const char *MFHTR(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
+    const char *ret = img_format("MFHTR %s, %s, %s, %s", rt, c0s, u, sel);
+    free((char *)c0s);
+    free((char *)u);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -10100,7 +10421,11 @@ static const char *MFTR(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
+    const char *ret = img_format("MFTR %s, %s, %s, %s", rt, c0s, u, sel);
+    free((char *)c0s);
+    free((char *)u);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -10336,7 +10661,9 @@ static const char *MOVE_BALC(uint64 instruction)
     const char *rtz4 = GPR(decode_gpr_gpr4_zero(rtz4_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 4);
 
-    return img_format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
+    const char *ret = img_format("MOVE.BALC %s, %s, %s", rd1, rtz4, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -10580,7 +10907,10 @@ static const char *MTC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MTC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("MTC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)c0s);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -10648,7 +10978,10 @@ static const char *MTGC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MTGC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("MTGC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)c0s);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -10672,7 +11005,10 @@ static const char *MTHC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MTHC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("MTHC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)c0s);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -10740,7 +11076,10 @@ static const char *MTHGC0(uint64 instruction)
     const char *c0s = CPR(copy(c0s_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MTHGC0 %s, %s, %s", rt, c0s, sel);
+    const char *ret = img_format("MTHGC0 %s, %s, %s", rt, c0s, sel);
+    free((char *)c0s);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -10808,7 +11147,11 @@ static const char *MTHTR(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
+    const char *ret = img_format("MTHTR %s, %s, %s, %s", rt, c0s, u, sel);
+    free((char *)c0s);
+    free((char *)u);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -10855,7 +11198,11 @@ static const char *MTTR(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
+    const char *ret = img_format("MTTR %s, %s, %s, %s", rt, c0s, u, sel);
+    free((char *)c0s);
+    free((char *)u);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -11431,7 +11778,7 @@ static const char *NOP_16_(uint64 instruction)
 {
     (void)instruction;
 
-    return "NOP ";
+    return strdup("NOP ");
 }
 
 
@@ -11449,7 +11796,7 @@ static const char *NOP_32_(uint64 instruction)
 {
     (void)instruction;
 
-    return "NOP ";
+    return strdup("NOP ");
 }
 
 
@@ -11565,7 +11912,9 @@ static const char *ORI(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("ORI %s, %s, %s", rt, rs, u);
+    const char *ret = img_format("ORI %s, %s, %s", rt, rs, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -11608,7 +11957,7 @@ static const char *PAUSE(uint64 instruction)
 {
     (void)instruction;
 
-    return "PAUSE ";
+    return strdup("PAUSE ");
 }
 
 
@@ -11940,7 +12289,9 @@ static const char *PRECR_SRA_PH_W(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("PRECR_SRA.PH.W %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -11965,7 +12316,9 @@ static const char *PRECR_SRA_R_PH_W(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("PRECR_SRA_R.PH.W %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -12089,7 +12442,10 @@ static const char *PREF_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("PREF %s, %s(%s)", hint, s, rs);
+    const char *ret = img_format("PREF %s, %s(%s)", hint, s, rs);
+    free((char *)hint);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -12113,7 +12469,10 @@ static const char *PREF_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("PREF %s, %s(%s)", hint, u, rs);
+    const char *ret = img_format("PREF %s, %s(%s)", hint, u, rs);
+    free((char *)hint);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -12137,7 +12496,10 @@ static const char *PREFE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("PREFE %s, %s(%s)", hint, s, rs);
+    const char *ret = img_format("PREFE %s, %s(%s)", hint, s, rs);
+    free((char *)hint);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -12161,7 +12523,9 @@ static const char *PREPEND(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("PREPEND %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("PREPEND %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -12203,7 +12567,9 @@ static const char *RDDSP(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *mask = IMMEDIATE(copy(mask_value));
 
-    return img_format("RDDSP %s, %s", rt, mask);
+    const char *ret = img_format("RDDSP %s, %s", rt, mask);
+    free((char *)mask);
+    return ret;
 }
 
 
@@ -12227,7 +12593,10 @@ static const char *RDHWR(uint64 instruction)
     const char *hs = CPR(copy(hs_value));
     const char *sel = IMMEDIATE(copy(sel_value));
 
-    return img_format("RDHWR %s, %s, %s", rt, hs, sel);
+    const char *ret = img_format("RDHWR %s, %s, %s", rt, hs, sel);
+    free((char *)hs);
+    free((char *)sel);
+    return ret;
 }
 
 
@@ -12316,6 +12685,7 @@ static const char *REPL_PH(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
 
     return img_format("REPL.PH %s, %s", rt, s);
+
 }
 
 
@@ -12337,7 +12707,9 @@ static const char *REPL_QB(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("REPL.QB %s, %s", rt, u);
+    const char *ret = img_format("REPL.QB %s, %s", rt, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -12402,8 +12774,13 @@ static const char *RESTORE_32_(uint64 instruction)
     uint64 gp_value = extract_gp_2(instruction);
 
     const char *u = IMMEDIATE(copy(u_value));
-    return img_format("RESTORE %s%s", u,
-               save_restore_list(rt_value, count_value, gp_value));
+    const char *save_restore_str = save_restore_list(
+        rt_value, count_value, gp_value);
+
+    const char *ret = img_format("RESTORE %s%s", u, save_restore_str);
+    free((char *)save_restore_str);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -12424,8 +12801,13 @@ static const char *RESTORE_JRC_16_(uint64 instruction)
     uint64 count_value = extract_count_3_2_1_0(instruction);
 
     const 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));
+    const char *save_restore_str = save_restore_list(
+        encode_rt1_from_rt(rt1_value), count_value, 0);
+
+    const char *ret = img_format("RESTORE.JRC %s%s", u, save_restore_str);
+    free((char *)u);
+    free((char *)save_restore_str);
+    return ret;
 }
 
 
@@ -12447,8 +12829,13 @@ static const char *RESTORE_JRC_32_(uint64 instruction)
     uint64 gp_value = extract_gp_2(instruction);
 
     const char *u = IMMEDIATE(copy(u_value));
-    return img_format("RESTORE.JRC %s%s", u,
-               save_restore_list(rt_value, count_value, gp_value));
+    const char *save_restore_str = save_restore_list(
+        rt_value, count_value, gp_value);
+
+    const char *ret = img_format("RESTORE.JRC %s%s", u, save_restore_str);
+    free((char *)u);
+    free((char *)save_restore_str);
+    return ret;
 }
 
 
@@ -12470,7 +12857,10 @@ static const char *RESTOREF(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *count = IMMEDIATE(copy(count_value));
 
-    return img_format("RESTOREF %s, %s", u, count);
+    const char *ret = img_format("RESTOREF %s, %s", u, count);
+    free((char *)u);
+    free((char *)count);
+    return ret;
 }
 
 
@@ -12538,7 +12928,9 @@ static const char *ROTR(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("ROTR %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("ROTR %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -12590,8 +12982,12 @@ static const char *ROTX(uint64 instruction)
     const char *shiftx = IMMEDIATE(copy(shiftx_value));
     const char *stripe = IMMEDIATE(copy(stripe_value));
 
-    return img_format("ROTX %s, %s, %s, %s, %s",
+    const char *ret = img_format("ROTX %s, %s, %s, %s, %s",
                        rt, rs, shift, shiftx, stripe);
+    free((char *)shift);
+    free((char *)shiftx);
+    free((char *)stripe);
+    return ret;
 }
 
 
@@ -12744,8 +13140,13 @@ static const char *SAVE_16_(uint64 instruction)
     uint64 count_value = extract_count_3_2_1_0(instruction);
 
     const 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));
+    const char *save_restore_str = save_restore_list(
+        encode_rt1_from_rt(rt1_value), count_value, 0);
+
+    const char *ret = img_format("SAVE %s%s", u, save_restore_str);
+    free((char *)u);
+    free((char *)save_restore_str);
+    return ret;
 }
 
 
@@ -12767,8 +13168,13 @@ static const char *SAVE_32_(uint64 instruction)
     uint64 gp_value = extract_gp_2(instruction);
 
     const char *u = IMMEDIATE(copy(u_value));
-    return img_format("SAVE %s%s", u,
-               save_restore_list(rt_value, count_value, gp_value));
+    const char *save_restore_str = save_restore_list(
+        rt_value, count_value, gp_value);
+
+    const char *ret = img_format("SAVE %s%s", u, save_restore_str);
+    free((char *)u);
+    free((char *)save_restore_str);
+    return ret;
 }
 
 
@@ -12790,7 +13196,10 @@ static const char *SAVEF(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *count = IMMEDIATE(copy(count_value));
 
-    return img_format("SAVEF %s, %s", u, count);
+    const char *ret = img_format("SAVEF %s, %s", u, count);
+    free((char *)u);
+    free((char *)count);
+    return ret;
 }
 
 
@@ -12814,7 +13223,9 @@ static const char *SB_16_(uint64 instruction)
     const 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);
+    const char *ret = img_format("SB %s, %s(%s)", rtz3, u, rs3);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -12836,7 +13247,9 @@ static const char *SB_GP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("SB %s, %s($%d)", rt, u, 28);
+    const char *ret = img_format("SB %s, %s($%d)", rt, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -12860,7 +13273,9 @@ static const char *SB_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SB %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("SB %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -12884,7 +13299,9 @@ static const char *SB_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SB %s, %s(%s)", rt, u, rs);
+    const char *ret = img_format("SB %s, %s(%s)", rt, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -12908,7 +13325,9 @@ static const char *SBE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SBE %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("SBE %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -12956,7 +13375,9 @@ static const char *SC(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SC %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("SC %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -12980,7 +13401,9 @@ static const char *SCD(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SCD %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("SCD %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -13028,7 +13451,9 @@ static const char *SCE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SCE %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("SCE %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -13098,7 +13523,9 @@ static const char *SD_GP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("SD %s, %s($%d)", rt, u, 28);
+    const char *ret = img_format("SD %s, %s($%d)", rt, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -13122,7 +13549,9 @@ static const char *SD_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SD %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("SD %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -13146,7 +13575,9 @@ static const char *SD_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SD %s, %s(%s)", rt, u, rs);
+    const char *ret = img_format("SD %s, %s(%s)", rt, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -13166,7 +13597,9 @@ static const char *SDBBP_16_(uint64 instruction)
 
     const char *code = IMMEDIATE(copy(code_value));
 
-    return img_format("SDBBP %s", code);
+    const char *ret = img_format("SDBBP %s", code);
+    free((char *)code);
+    return ret;
 }
 
 
@@ -13186,7 +13619,9 @@ static const char *SDBBP_32_(uint64 instruction)
 
     const char *code = IMMEDIATE(copy(code_value));
 
-    return img_format("SDBBP %s", code);
+    const char *ret = img_format("SDBBP %s", code);
+    free((char *)code);
+    return ret;
 }
 
 
@@ -13208,7 +13643,9 @@ static const char *SDC1_GP_(uint64 instruction)
     const char *ft = FPR(copy(ft_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("SDC1 %s, %s($%d)", ft, u, 28);
+    const char *ret = img_format("SDC1 %s, %s($%d)", ft, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -13232,7 +13669,9 @@ static const char *SDC1_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SDC1 %s, %s(%s)", ft, s, rs);
+    const char *ret = img_format("SDC1 %s, %s(%s)", ft, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -13256,7 +13695,9 @@ static const char *SDC1_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SDC1 %s, %s(%s)", ft, u, rs);
+    const char *ret = img_format("SDC1 %s, %s(%s)", ft, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -13328,7 +13769,9 @@ static const char *SDC2(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SDC2 %s, %s(%s)", cs, s, rs);
+    const char *ret = img_format("SDC2 %s, %s(%s)", cs, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -13354,7 +13797,10 @@ static const char *SDM(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img_format("SDM %s, %s(%s), %s", rt, s, rs, count3);
+    const char *ret = img_format("SDM %s, %s(%s), %s", rt, s, rs, count3);
+    free((char *)s);
+    free((char *)count3);
+    return ret;
 }
 
 
@@ -13376,7 +13822,9 @@ static const char *SDPC_48_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 6);
 
-    return img_format("SDPC %s, %s", rt, s);
+    const char *ret = img_format("SDPC %s, %s", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -13636,7 +14084,9 @@ static const char *SEQI(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("SEQI %s, %s, %s", rt, rs, u);
+    const char *ret = img_format("SEQI %s, %s, %s", rt, rs, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -13660,7 +14110,9 @@ static const char *SH_16_(uint64 instruction)
     const 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);
+    const char *ret = img_format("SH %s, %s(%s)", rtz3, u, rs3);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -13682,7 +14134,9 @@ static const char *SH_GP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("SH %s, %s($%d)", rt, u, 28);
+    const char *ret = img_format("SH %s, %s($%d)", rt, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -13706,7 +14160,9 @@ static const char *SH_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SH %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("SH %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -13730,7 +14186,9 @@ static const char *SH_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SH %s, %s(%s)", rt, u, rs);
+    const char *ret = img_format("SH %s, %s(%s)", rt, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -13754,7 +14212,9 @@ static const char *SHE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SHE %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("SHE %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -13776,7 +14236,9 @@ static const char *SHILO(uint64 instruction)
     const char *shift = IMMEDIATE(copy(shift_value));
     const char *ac = AC(copy(ac_value));
 
-    return img_format("SHILO %s, %s", ac, shift);
+    const char *ret = img_format("SHILO %s, %s", ac, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -13822,7 +14284,9 @@ static const char *SHLL_PH(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("SHLL.PH %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("SHLL.PH %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -13846,7 +14310,9 @@ static const char *SHLL_QB(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("SHLL.QB %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("SHLL.QB %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -13871,7 +14337,9 @@ static const char *SHLL_S_PH(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("SHLL_S.PH %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -13895,7 +14363,9 @@ static const char *SHLL_S_W(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("SHLL_S.W %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("SHLL_S.W %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -14017,7 +14487,9 @@ static const char *SHRA_PH(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("SHRA.PH %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("SHRA.PH %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -14041,7 +14513,9 @@ static const char *SHRA_QB(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("SHRA.QB %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("SHRA.QB %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -14065,7 +14539,9 @@ static const char *SHRA_R_PH(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("SHRA_R.PH %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -14089,7 +14565,9 @@ static const char *SHRA_R_QB(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("SHRA_R.QB %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -14113,7 +14591,9 @@ static const char *SHRA_R_W(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("SHRA_R.W %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("SHRA_R.W %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -14257,7 +14737,9 @@ static const char *SHRL_PH(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("SHRL.PH %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("SHRL.PH %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -14281,7 +14763,9 @@ static const char *SHRL_QB(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *sa = IMMEDIATE(copy(sa_value));
 
-    return img_format("SHRL.QB %s, %s, %s", rt, rs, sa);
+    const char *ret = img_format("SHRL.QB %s, %s, %s", rt, rs, sa);
+    free((char *)sa);
+    return ret;
 }
 
 
@@ -14398,7 +14882,9 @@ static const char *SIGRIE(uint64 instruction)
 
     const char *code = IMMEDIATE(copy(code_value));
 
-    return img_format("SIGRIE %s", code);
+    const char *ret = img_format("SIGRIE %s", code);
+    free((char *)code);
+    return ret;
 }
 
 
@@ -14422,7 +14908,9 @@ static const char *SLL_16_(uint64 instruction)
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
     const char *shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
 
-    return img_format("SLL %s, %s, %s", rt3, rs3, shift3);
+    const char *ret = img_format("SLL %s, %s, %s", rt3, rs3, shift3);
+    free((char *)shift3);
+    return ret;
 }
 
 
@@ -14446,7 +14934,9 @@ static const char *SLL_32_(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("SLL %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("SLL %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -14518,7 +15008,9 @@ static const char *SLTI(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("SLTI %s, %s, %s", rt, rs, u);
+    const char *ret = img_format("SLTI %s, %s, %s", rt, rs, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -14542,7 +15034,9 @@ static const char *SLTIU(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("SLTIU %s, %s, %s", rt, rs, u);
+    const char *ret = img_format("SLTIU %s, %s, %s", rt, rs, u);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -14610,7 +15104,9 @@ static const char *SPECIAL2(uint64 instruction)
 
     const char *op = IMMEDIATE(copy(op_value));
 
-    return img_format("SPECIAL2 %s", op);
+    const char *ret = img_format("SPECIAL2 %s", op);
+    free((char *)op);
+    return ret;
 }
 
 
@@ -14678,7 +15174,9 @@ static const char *SRA(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("SRA %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("SRA %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -14726,7 +15224,9 @@ static const char *SRL_16_(uint64 instruction)
     const char *rs3 = GPR(decode_gpr_gpr3(rs3_value));
     const char *shift3 = IMMEDIATE(encode_shift3_from_shift(shift3_value));
 
-    return img_format("SRL %s, %s, %s", rt3, rs3, shift3);
+    const char *ret = img_format("SRL %s, %s, %s", rt3, rs3, shift3);
+    free((char *)shift3);
+    return ret;
 }
 
 
@@ -14750,7 +15250,9 @@ static const char *SRL_32_(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *shift = IMMEDIATE(copy(shift_value));
 
-    return img_format("SRL %s, %s, %s", rt, rs, shift);
+    const char *ret = img_format("SRL %s, %s, %s", rt, rs, shift);
+    free((char *)shift);
+    return ret;
 }
 
 
@@ -15240,7 +15742,9 @@ static const char *SW_16_(uint64 instruction)
     const 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);
+    const char *ret = img_format("SW %s, %s(%s)", rtz3, u, rs3);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -15264,7 +15768,9 @@ static const char *SW_4X4_(uint64 instruction)
     const 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);
+    const char *ret = img_format("SW %s, %s(%s)", rtz4, u, rs4);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -15286,7 +15792,9 @@ static const char *SW_GP16_(uint64 instruction)
     const char *rtz3 = GPR(decode_gpr_gpr3_src_store(rtz3_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("SW %s, %s($%d)", rtz3, u, 28);
+    const char *ret = img_format("SW %s, %s($%d)", rtz3, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -15308,7 +15816,9 @@ static const char *SW_GP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("SW %s, %s($%d)", rt, u, 28);
+    const char *ret = img_format("SW %s, %s($%d)", rt, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -15332,7 +15842,9 @@ static const char *SW_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SW %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("SW %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -15354,7 +15866,9 @@ static const char *SW_SP_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("SW %s, %s($%d)", rt, u, 29);
+    const char *ret = img_format("SW %s, %s($%d)", rt, u, 29);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -15378,7 +15892,9 @@ static const char *SW_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SW %s, %s(%s)", rt, u, rs);
+    const char *ret = img_format("SW %s, %s(%s)", rt, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -15400,7 +15916,9 @@ static const char *SWC1_GP_(uint64 instruction)
     const char *ft = FPR(copy(ft_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("SWC1 %s, %s($%d)", ft, u, 28);
+    const char *ret = img_format("SWC1 %s, %s($%d)", ft, u, 28);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -15424,7 +15942,9 @@ static const char *SWC1_S9_(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SWC1 %s, %s(%s)", ft, s, rs);
+    const char *ret = img_format("SWC1 %s, %s(%s)", ft, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -15448,7 +15968,9 @@ static const char *SWC1_U12_(uint64 instruction)
     const char *u = IMMEDIATE(copy(u_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SWC1 %s, %s(%s)", ft, u, rs);
+    const char *ret = img_format("SWC1 %s, %s(%s)", ft, u, rs);
+    free((char *)u);
+    return ret;
 }
 
 
@@ -15520,7 +16042,9 @@ static const char *SWC2(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SWC2 %s, %s(%s)", cs, s, rs);
+    const char *ret = img_format("SWC2 %s, %s(%s)", cs, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -15544,7 +16068,9 @@ static const char *SWE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SWE %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("SWE %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -15570,7 +16096,10 @@ static const char *SWM(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img_format("SWM %s, %s(%s), %s", rt, s, rs, count3);
+    const char *ret = img_format("SWM %s, %s(%s), %s", rt, s, rs, count3);
+    free((char *)s);
+    free((char *)count3);
+    return ret;
 }
 
 
@@ -15592,7 +16121,9 @@ static const char *SWPC_48_(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *s = ADDRESS(encode_s_from_address(s_value), 6);
 
-    return img_format("SWPC %s, %s", rt, s);
+    const char *ret = img_format("SWPC %s, %s", rt, s);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -15660,7 +16191,9 @@ static const char *SYNC(uint64 instruction)
 
     const char *stype = IMMEDIATE(copy(stype_value));
 
-    return img_format("SYNC %s", stype);
+    const char *ret = img_format("SYNC %s", stype);
+    free((char *)stype);
+    return ret;
 }
 
 
@@ -15682,7 +16215,9 @@ static const char *SYNCI(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SYNCI %s(%s)", s, rs);
+    const char *ret = img_format("SYNCI %s(%s)", s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -15704,7 +16239,9 @@ static const char *SYNCIE(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("SYNCIE %s(%s)", s, rs);
+    const char *ret = img_format("SYNCIE %s(%s)", s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -15724,7 +16261,9 @@ static const char *SYSCALL_16_(uint64 instruction)
 
     const char *code = IMMEDIATE(copy(code_value));
 
-    return img_format("SYSCALL %s", code);
+    const char *ret = img_format("SYSCALL %s", code);
+    free((char *)code);
+    return ret;
 }
 
 
@@ -15742,7 +16281,9 @@ static const char *SYSCALL_32_(uint64 instruction)
 
     const char *code = IMMEDIATE(copy(code_value));
 
-    return img_format("SYSCALL %s", code);
+    const char *ret = img_format("SYSCALL %s", code);
+    free((char *)code);
+    return ret;
 }
 
 
@@ -15782,7 +16323,7 @@ static const char *TLBGINV(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBGINV ";
+    return strdup("TLBGINV ");
 }
 
 
@@ -15800,7 +16341,7 @@ static const char *TLBGINVF(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBGINVF ";
+    return strdup("TLBGINVF ");
 }
 
 
@@ -15818,7 +16359,7 @@ static const char *TLBGP(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBGP ";
+    return strdup("TLBGP ");
 }
 
 
@@ -15836,7 +16377,7 @@ static const char *TLBGR(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBGR ";
+    return strdup("TLBGR ");
 }
 
 
@@ -15854,7 +16395,7 @@ static const char *TLBGWI(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBGWI ";
+    return strdup("TLBGWI ");
 }
 
 
@@ -15872,7 +16413,7 @@ static const char *TLBGWR(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBGWR ";
+    return strdup("TLBGWR ");
 }
 
 
@@ -15890,7 +16431,7 @@ static const char *TLBINV(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBINV ";
+    return strdup("TLBINV ");
 }
 
 
@@ -15908,7 +16449,7 @@ static const char *TLBINVF(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBINVF ";
+    return strdup("TLBINVF ");
 }
 
 
@@ -15926,7 +16467,7 @@ static const char *TLBP(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBP ";
+    return strdup("TLBP ");
 }
 
 
@@ -15944,7 +16485,7 @@ static const char *TLBR(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBR ";
+    return strdup("TLBR ");
 }
 
 
@@ -15962,7 +16503,7 @@ static const char *TLBWI(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBWI ";
+    return strdup("TLBWI ");
 }
 
 
@@ -15980,7 +16521,7 @@ static const char *TLBWR(uint64 instruction)
 {
     (void)instruction;
 
-    return "TLBWR ";
+    return strdup("TLBWR ");
 }
 
 
@@ -16116,7 +16657,10 @@ static const char *UALDM(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img_format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
+    const char *ret = img_format("UALDM %s, %s(%s), %s", rt, s, rs, count3);
+    free((char *)s);
+    free((char *)count3);
+    return ret;
 }
 
 
@@ -16140,7 +16684,9 @@ static const char *UALH(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("UALH %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("UALH %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -16166,7 +16712,10 @@ static const char *UALWM(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img_format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
+    const char *ret = img_format("UALWM %s, %s(%s), %s", rt, s, rs, count3);
+    free((char *)s);
+    free((char *)count3);
+    return ret;
 }
 
 
@@ -16192,7 +16741,10 @@ static const char *UASDM(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img_format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
+    const char *ret = img_format("UASDM %s, %s(%s), %s", rt, s, rs, count3);
+    free((char *)s);
+    free((char *)count3);
+    return ret;
 }
 
 
@@ -16216,7 +16768,9 @@ static const char *UASH(uint64 instruction)
     const char *s = IMMEDIATE(copy(s_value));
     const char *rs = GPR(copy(rs_value));
 
-    return img_format("UASH %s, %s(%s)", rt, s, rs);
+    const char *ret = img_format("UASH %s, %s(%s)", rt, s, rs);
+    free((char *)s);
+    return ret;
 }
 
 
@@ -16242,7 +16796,10 @@ static const char *UASWM(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *count3 = IMMEDIATE(encode_count3_from_count(count3_value));
 
-    return img_format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
+    const char *ret = img_format("UASWM %s, %s(%s), %s", rt, s, rs, count3);
+    free((char *)s);
+    free((char *)count3);
+    return ret;
 }
 
 
@@ -16262,7 +16819,9 @@ static const char *UDI(uint64 instruction)
 
     const char *op = IMMEDIATE(copy(op_value));
 
-    return img_format("UDI %s", op);
+    const char *ret = img_format("UDI %s", op);
+    free((char *)op);
+    return ret;
 }
 
 
@@ -16280,7 +16839,9 @@ static const char *WAIT(uint64 instruction)
 
     const char *code = IMMEDIATE(copy(code_value));
 
-    return img_format("WAIT %s", code);
+    const char *ret = img_format("WAIT %s", code);
+    free((char *)code);
+    return ret;
 }
 
 
@@ -16302,7 +16863,9 @@ static const char *WRDSP(uint64 instruction)
     const char *rt = GPR(copy(rt_value));
     const char *mask = IMMEDIATE(copy(mask_value));
 
-    return img_format("WRDSP %s, %s", rt, mask);
+    const char *ret = img_format("WRDSP %s, %s", rt, mask);
+    free((char *)mask);
+    return ret;
 }
 
 
@@ -16394,7 +16957,9 @@ static const char *XORI(uint64 instruction)
     const char *rs = GPR(copy(rs_value));
     const char *u = IMMEDIATE(copy(u_value));
 
-    return img_format("XORI %s, %s, %s", rt, rs, u);
+    const char *ret = img_format("XORI %s, %s, %s", rt, rs, u);
+    free((char *)u);
+    return ret;
 }
 
 
