/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|*  * Mips Disassembler                                                       *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/


#include "llvm/MC/MCInst.h"
#include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/LEB128.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TargetParser/SubtargetFeature.h"
#include <assert.h>

namespace {

// InsnBitWidth is essentially a type trait used by the decoder emitter to query
// the supported bitwidth for a given type. But default, the value is 0, making
// it an invalid type for use as `InsnType` when instantiating the decoder.
// Individual targets are expected to provide specializations for these based
// on their usage.
template <typename T> constexpr uint32_t InsnBitWidth = 0;

[[maybe_unused]]
static DecodeStatus Decodemips_ptr_rcRegClassByHwMode(MCInst &Inst, unsigned Imm, uint64_t Addr, const MCDisassembler *Decoder) {
  switch (Decoder->getSubtargetInfo().getHwMode(MCSubtargetInfo::HwMode_RegInfo)) {
  case 0: // DefaultMode
    return DecodeGPR32RegisterClass(Inst, Imm, Addr, Decoder);
  case 1: // MIPS64
    return DecodeGPR64RegisterClass(Inst, Imm, Addr, Decoder);
  default:
    llvm_unreachable("no decoder for hwmode");
  }
}

[[maybe_unused]]
static DecodeStatus Decodeptr_gp_rcRegClassByHwMode(MCInst &Inst, unsigned Imm, uint64_t Addr, const MCDisassembler *Decoder) {
  switch (Decoder->getSubtargetInfo().getHwMode(MCSubtargetInfo::HwMode_RegInfo)) {
  case 0: // DefaultMode
    return DecodeGP32RegisterClass(Inst, Imm, Addr, Decoder);
  case 1: // MIPS64
    return DecodeGP64RegisterClass(Inst, Imm, Addr, Decoder);
  default:
    llvm_unreachable("no decoder for hwmode");
  }
}

[[maybe_unused]]
static DecodeStatus Decodeptr_gpr16mm_rcRegClassByHwMode(MCInst &Inst, unsigned Imm, uint64_t Addr, const MCDisassembler *Decoder) {
  switch (Decoder->getSubtargetInfo().getHwMode(MCSubtargetInfo::HwMode_RegInfo)) {
  case 0: // DefaultMode
    return DecodeGPRMM16RegisterClass(Inst, Imm, Addr, Decoder);
  case 1: // MIPS64
    return DecodeGPRMM16RegisterClass(Inst, Imm, Addr, Decoder);
  default:
    llvm_unreachable("no decoder for hwmode");
  }
}

[[maybe_unused]]
static DecodeStatus Decodeptr_sp_rcRegClassByHwMode(MCInst &Inst, unsigned Imm, uint64_t Addr, const MCDisassembler *Decoder) {
  switch (Decoder->getSubtargetInfo().getHwMode(MCSubtargetInfo::HwMode_RegInfo)) {
  case 0: // DefaultMode
    return DecodeSP32RegisterClass(Inst, Imm, Addr, Decoder);
  case 1: // MIPS64
    return DecodeSP64RegisterClass(Inst, Imm, Addr, Decoder);
  default:
    llvm_unreachable("no decoder for hwmode");
  }
}


static const uint8_t DecoderTable16[352] = {
  OPC_SwitchField, 11, 5,                    //   0: switch Inst[15:11] {
  2, 6,                                      //   3: case 0x2: {
  OPC_CheckPredicate, 0,                     //   5:  check predicate 0
  OPC_Decode, 210, 8, 0,                     //   7:  decode to Bimm16 using decoder 0
                                             //   7: }
  4, 6,                                      //  11: case 0x4: {
  OPC_CheckPredicate, 0,                     //  13:  check predicate 0
  OPC_Decode, 208, 8, 1,                     //  15:  decode to BeqzRxImm16 using decoder 1
                                             //  15: }
  5, 6,                                      //  19: case 0x5: {
  OPC_CheckPredicate, 0,                     //  21:  check predicate 0
  OPC_Decode, 212, 8, 1,                     //  23:  decode to BnezRxImm16 using decoder 1
                                             //  23: }
  9, 6,                                      //  27: case 0x9: {
  OPC_CheckPredicate, 0,                     //  29:  check predicate 0
  OPC_Decode, 143, 7, 2,                     //  31:  decode to AddiuRxRxImm16 using decoder 2
                                             //  31: }
  10, 6,                                     //  35: case 0xa: {
  OPC_CheckPredicate, 0,                     //  37:  check predicate 0
  OPC_Decode, 129, 22, 3,                    //  39:  decode to SltiRxImm16 using decoder 3
                                             //  39: }
  11, 6,                                     //  43: case 0xb: {
  OPC_CheckPredicate, 0,                     //  45:  check predicate 0
  OPC_Decode, 131, 22, 3,                    //  47:  decode to SltiuRxImm16 using decoder 3
                                             //  47: }
  12, 43,                                    //  51: case 0xc: {
  OPC_SwitchField, 8, 3,                     //  53:  switch Inst[10:8] {
  0, 6,                                      //  56:  case 0x0: {
  OPC_CheckPredicate, 0,                     //  58:   check predicate 0
  OPC_Decode, 215, 8, 4,                     //  60:   decode to Bteqz16 using decoder 4
                                             //  60:  }
  1, 6,                                      //  64:  case 0x1: {
  OPC_CheckPredicate, 0,                     //  66:   check predicate 0
  OPC_Decode, 217, 8, 4,                     //  68:   decode to Btnez16 using decoder 4
                                             //  68:  }
  3, 6,                                      //  72:  case 0x3: {
  OPC_CheckPredicate, 0,                     //  74:   check predicate 0
  OPC_Decode, 146, 7, 4,                     //  76:   decode to AddiuSpImm16 using decoder 4
                                             //  76:  }
  5, 6,                                      //  80:  case 0x5: {
  OPC_CheckPredicate, 0,                     //  82:   check predicate 0
  OPC_Decode, 133, 18, 5,                    //  84:   decode to Move32R16 using decoder 5
                                             //  84:  }
  7, 0,                                      //  88:  case 0x7: {
  OPC_CheckPredicate, 0,                     //  90:   check predicate 0
  OPC_Decode, 134, 18, 6,                    //  92:   decode to MoveR3216 using decoder 6
                                             //  92:  }
                                             //  92:  } // switch Inst[10:8]
                                             //  92: }
  13, 6,                                     //  96: case 0xd: {
  OPC_CheckPredicate, 0,                     //  98:  check predicate 0
  OPC_Decode, 215, 15, 3,                    // 100:  decode to LiRxImm16 using decoder 3
                                             // 100: }
  14, 6,                                     // 104: case 0xe: {
  OPC_CheckPredicate, 0,                     // 106:  check predicate 0
  OPC_Decode, 153, 11, 3,                    // 108:  decode to CmpiRxImm16 using decoder 3
                                             // 108: }
  22, 6,                                     // 112: case 0x16: {
  OPC_CheckPredicate, 0,                     // 114:  check predicate 0
  OPC_Decode, 218, 15, 7,                    // 116:  decode to LwRxPcTcp16 using decoder 7
                                             // 116: }
  28, 19,                                    // 120: case 0x1c: {
  OPC_SwitchField, 0, 2,                     // 122:  switch Inst[1:0] {
  1, 6,                                      // 125:  case 0x1: {
  OPC_CheckPredicate, 0,                     // 127:   check predicate 0
  OPC_Decode, 148, 7, 8,                     // 129:   decode to AdduRxRyRz16 using decoder 8
                                             // 129:  }
  3, 0,                                      // 133:  case 0x3: {
  OPC_CheckPredicate, 0,                     // 135:   check predicate 0
  OPC_Decode, 138, 22, 8,                    // 137:   decode to SubuRxRyRz16 using decoder 8
                                             // 137:  }
                                             // 137:  } // switch Inst[1:0]
                                             // 137: }
  29, 0,                                     // 141: case 0x1d: {
  OPC_SwitchField, 0, 5,                     // 143:  switch Inst[4:0] {
  0, 43,                                     // 146:  case 0x0: {
  OPC_SwitchField, 5, 3,                     // 148:   switch Inst[7:5] {
  0, 6,                                      // 151:   case 0x0: {
  OPC_CheckPredicate, 0,                     // 153:    check predicate 0
  OPC_Decode, 221, 14, 9,                    // 155:    decode to JumpLinkReg16 using decoder 9
                                             // 155:   }
  1, 10,                                     // 159:   case 0x1: {
  OPC_CheckPredicate, 0,                     // 161:    check predicate 0
  OPC_CheckField, 8, 3, 0,                   // 163:    check Inst[10:8] == 0x0
  OPC_Decode, 218, 14, 10,                   // 167:    decode to JrRa16 using decoder 10
                                             // 167:   }
  6, 6,                                      // 171:   case 0x6: {
  OPC_CheckPredicate, 0,                     // 173:    check predicate 0
  OPC_Decode, 220, 14, 9,                    // 175:    decode to JrcRx16 using decoder 9
                                             // 175:   }
  7, 0,                                      // 179:   case 0x7: {
  OPC_CheckPredicate, 0,                     // 181:    check predicate 0
  OPC_CheckField, 8, 3, 0,                   // 183:    check Inst[10:8] == 0x0
  OPC_Decode, 219, 14, 10,                   // 187:    decode to JrcRa16 using decoder 10
                                             // 187:   }
                                             // 187:   } // switch Inst[7:5]
                                             // 187:  }
  2, 6,                                      // 191:  case 0x2: {
  OPC_CheckPredicate, 0,                     // 193:   check predicate 0
  OPC_Decode, 128, 22, 11,                   // 195:   decode to SltRxRy16 using decoder 11
                                             // 195:  }
  3, 6,                                      // 199:  case 0x3: {
  OPC_CheckPredicate, 0,                     // 201:   check predicate 0
  OPC_Decode, 133, 22, 11,                   // 203:   decode to SltuRxRy16 using decoder 11
                                             // 203:  }
  4, 6,                                      // 207:  case 0x4: {
  OPC_CheckPredicate, 0,                     // 209:   check predicate 0
  OPC_Decode, 255, 21, 12,                   // 211:   decode to SllvRxRy16 using decoder 12
                                             // 211:  }
  5, 10,                                     // 215:  case 0x5: {
  OPC_CheckPredicate, 0,                     // 217:   check predicate 0
  OPC_CheckField, 5, 6, 0,                   // 219:   check Inst[10:5] == 0x0
  OPC_Decode, 214, 8, 10,                    // 223:   decode to Break16 using decoder 10
                                             // 223:  }
  6, 6,                                      // 227:  case 0x6: {
  OPC_CheckPredicate, 0,                     // 229:   check predicate 0
  OPC_Decode, 137, 22, 12,                   // 231:   decode to SrlvRxRy16 using decoder 12
                                             // 231:  }
  7, 6,                                      // 235:  case 0x7: {
  OPC_CheckPredicate, 0,                     // 237:   check predicate 0
  OPC_Decode, 135, 22, 12,                   // 239:   decode to SravRxRy16 using decoder 12
                                             // 239:  }
  10, 6,                                     // 243:  case 0xa: {
  OPC_CheckPredicate, 0,                     // 245:   check predicate 0
  OPC_Decode, 152, 11, 11,                   // 247:   decode to CmpRxRy16 using decoder 11
                                             // 247:  }
  12, 6,                                     // 251:  case 0xc: {
  OPC_CheckPredicate, 0,                     // 253:   check predicate 0
  OPC_Decode, 149, 7, 12,                    // 255:   decode to AndRxRxRy16 using decoder 12
                                             // 255:  }
  13, 6,                                     // 259:  case 0xd: {
  OPC_CheckPredicate, 0,                     // 261:   check predicate 0
  OPC_Decode, 176, 18, 12,                   // 263:   decode to OrRxRxRy16 using decoder 12
                                             // 263:  }
  14, 6,                                     // 267:  case 0xe: {
  OPC_CheckPredicate, 0,                     // 269:   check predicate 0
  OPC_Decode, 230, 22, 12,                   // 271:   decode to XorRxRxRy16 using decoder 12
                                             // 271:  }
  15, 6,                                     // 275:  case 0xf: {
  OPC_CheckPredicate, 0,                     // 277:   check predicate 0
  OPC_Decode, 163, 18, 11,                   // 279:   decode to NotRxRy16 using decoder 11
                                             // 279:  }
  16, 10,                                    // 283:  case 0x10: {
  OPC_CheckPredicate, 0,                     // 285:   check predicate 0
  OPC_CheckField, 5, 3, 0,                   // 287:   check Inst[7:5] == 0x0
  OPC_Decode, 131, 18, 9,                    // 291:   decode to Mfhi16 using decoder 9
                                             // 291:  }
  17, 19,                                    // 295:  case 0x11: {
  OPC_SwitchField, 5, 3,                     // 297:   switch Inst[7:5] {
  4, 6,                                      // 300:   case 0x4: {
  OPC_CheckPredicate, 0,                     // 302:    check predicate 0
  OPC_Decode, 251, 21, 13,                   // 304:    decode to SebRx16 using decoder 13
                                             // 304:   }
  5, 0,                                      // 308:   case 0x5: {
  OPC_CheckPredicate, 0,                     // 310:    check predicate 0
  OPC_Decode, 252, 21, 13,                   // 312:    decode to SehRx16 using decoder 13
                                             // 312:   }
                                             // 312:   } // switch Inst[7:5]
                                             // 312:  }
  18, 10,                                    // 316:  case 0x12: {
  OPC_CheckPredicate, 0,                     // 318:   check predicate 0
  OPC_CheckField, 5, 3, 0,                   // 320:   check Inst[7:5] == 0x0
  OPC_Decode, 132, 18, 9,                    // 324:   decode to Mflo16 using decoder 9
                                             // 324:  }
  26, 6,                                     // 328:  case 0x1a: {
  OPC_CheckPredicate, 0,                     // 330:   check predicate 0
  OPC_Decode, 162, 12, 11,                   // 332:   decode to DivRxRy16 using decoder 11
                                             // 332:  }
  27, 6,                                     // 336:  case 0x1b: {
  OPC_CheckPredicate, 0,                     // 338:   check predicate 0
  OPC_Decode, 163, 12, 11,                   // 340:   decode to DivuRxRy16 using decoder 11
                                             // 340:  }
  29, 0,                                     // 344:  case 0x1d: {
  OPC_CheckPredicate, 0,                     // 346:   check predicate 0
  OPC_Decode, 162, 18, 11,                   // 348:   decode to NegRxRy16 using decoder 11
                                             // 348:  }
                                             // 348:  } // switch Inst[4:0]
                                             // 348: }
                                             // 348: } // switch Inst[15:11]
};
static const uint8_t DecoderTableMicroMips16[375] = {
  OPC_SwitchField, 10, 6,                    //   0: switch Inst[15:10] {
  1, 19,                                     //   3: case 0x1: {
  OPC_SwitchField, 0, 1,                     //   5:  switch Inst[0] {
  0, 6,                                      //   8:  case 0x0: {
  OPC_CheckPredicate, 1,                     //  10:   check predicate 1
  OPC_Decode, 184, 6, 14,                    //  12:   decode to ADDU16_MM using decoder 14
                                             //  12:  }
  1, 0,                                      //  16:  case 0x1: {
  OPC_CheckPredicate, 1,                     //  18:   check predicate 1
  OPC_Decode, 176, 21, 14,                   //  20:   decode to SUBU16_MM using decoder 14
                                             //  20:  }
                                             //  20:  } // switch Inst[0]
                                             //  20: }
  2, 6,                                      //  24: case 0x2: {
  OPC_CheckPredicate, 2,                     //  26:  check predicate 2
  OPC_Decode, 226, 14, 15,                   //  28:  decode to LBU16_MM using decoder 15
                                             //  28: }
  3, 6,                                      //  32: case 0x3: {
  OPC_CheckPredicate, 1,                     //  34:  check predicate 1
  OPC_Decode, 228, 16, 16,                   //  36:  decode to MOVE16_MM using decoder 16
                                             //  36: }
  9, 19,                                     //  40: case 0x9: {
  OPC_SwitchField, 0, 1,                     //  42:  switch Inst[0] {
  0, 6,                                      //  45:  case 0x0: {
  OPC_CheckPredicate, 1,                     //  47:   check predicate 1
  OPC_Decode, 186, 20, 17,                   //  49:   decode to SLL16_MM using decoder 17
                                             //  49:  }
  1, 0,                                      //  53:  case 0x1: {
  OPC_CheckPredicate, 1,                     //  55:   check predicate 1
  OPC_Decode, 245, 20, 17,                   //  57:   decode to SRL16_MM using decoder 17
                                             //  57:  }
                                             //  57:  } // switch Inst[0]
                                             //  57: }
  10, 6,                                     //  61: case 0xa: {
  OPC_CheckPredicate, 2,                     //  63:  check predicate 2
  OPC_Decode, 139, 15, 15,                   //  65:  decode to LHU16_MM using decoder 15
                                             //  65: }
  11, 6,                                     //  69: case 0xb: {
  OPC_CheckPredicate, 1,                     //  71:  check predicate 1
  OPC_Decode, 229, 6, 18,                    //  73:  decode to ANDI16_MM using decoder 18
                                             //  73: }
  17, 153, 1,                                //  77: case 0x11: {
  OPC_SwitchField, 6, 4,                     //  80:  switch Inst[9:6] {
  0, 6,                                      //  83:  case 0x0: {
  OPC_CheckPredicate, 1,                     //  85:   check predicate 1
  OPC_Decode, 160, 18, 19,                   //  87:   decode to NOT16_MM using decoder 19
                                             //  87:  }
  1, 6,                                      //  91:  case 0x1: {
  OPC_CheckPredicate, 1,                     //  93:   check predicate 1
  OPC_Decode, 219, 22, 20,                   //  95:   decode to XOR16_MM using decoder 20
                                             //  95:  }
  2, 6,                                      //  99:  case 0x2: {
  OPC_CheckPredicate, 1,                     // 101:   check predicate 1
  OPC_Decode, 226, 6, 20,                    // 103:   decode to AND16_MM using decoder 20
                                             // 103:  }
  3, 6,                                      // 107:  case 0x3: {
  OPC_CheckPredicate, 1,                     // 109:   check predicate 1
  OPC_Decode, 165, 18, 20,                   // 111:   decode to OR16_MM using decoder 20
                                             // 111:  }
  4, 6,                                      // 115:  case 0x4: {
  OPC_CheckPredicate, 1,                     // 117:   check predicate 1
  OPC_Decode, 189, 15, 21,                   // 119:   decode to LWM16_MM using decoder 21
                                             // 119:  }
  5, 6,                                      // 123:  case 0x5: {
  OPC_CheckPredicate, 1,                     // 125:   check predicate 1
  OPC_Decode, 225, 21, 21,                   // 127:   decode to SWM16_MM using decoder 21
                                             // 127:  }
  6, 19,                                     // 131:  case 0x6: {
  OPC_SwitchField, 5, 1,                     // 133:   switch Inst[5] {
  0, 6,                                      // 136:   case 0x0: {
  OPC_CheckPredicate, 1,                     // 138:    check predicate 1
  OPC_Decode, 204, 14, 22,                   // 140:    decode to JR16_MM using decoder 22
                                             // 140:   }
  1, 0,                                      // 144:   case 0x1: {
  OPC_CheckPredicate, 1,                     // 146:    check predicate 1
  OPC_Decode, 207, 14, 22,                   // 148:    decode to JRC16_MM using decoder 22
                                             // 148:   }
                                             // 148:   } // switch Inst[5]
                                             // 148:  }
  7, 19,                                     // 152:  case 0x7: {
  OPC_SwitchField, 5, 1,                     // 154:   switch Inst[5] {
  0, 6,                                      // 157:   case 0x0: {
  OPC_CheckPredicate, 1,                     // 159:    check predicate 1
  OPC_Decode, 183, 14, 22,                   // 161:    decode to JALR16_MM using decoder 22
                                             // 161:   }
  1, 0,                                      // 165:   case 0x1: {
  OPC_CheckPredicate, 1,                     // 167:    check predicate 1
  OPC_Decode, 188, 14, 22,                   // 169:    decode to JALRS16_MM using decoder 22
                                             // 169:   }
                                             // 169:   } // switch Inst[5]
                                             // 169:  }
  8, 10,                                     // 173:  case 0x8: {
  OPC_CheckPredicate, 1,                     // 175:   check predicate 1
  OPC_CheckField, 5, 1, 0,                   // 177:   check Inst[5] == 0x0
  OPC_Decode, 174, 16, 22,                   // 181:   decode to MFHI16_MM using decoder 22
                                             // 181:  }
  9, 10,                                     // 185:  case 0x9: {
  OPC_CheckPredicate, 1,                     // 187:   check predicate 1
  OPC_CheckField, 5, 1, 0,                   // 189:   check Inst[5] == 0x0
  OPC_Decode, 180, 16, 22,                   // 193:   decode to MFLO16_MM using decoder 22
                                             // 193:  }
  10, 10,                                    // 197:  case 0xa: {
  OPC_CheckPredicate, 1,                     // 199:   check predicate 1
  OPC_CheckField, 4, 2, 0,                   // 201:   check Inst[5:4] == 0x0
  OPC_Decode, 189, 8, 23,                    // 205:   decode to BREAK16_MM using decoder 23
                                             // 205:  }
  11, 10,                                    // 209:  case 0xb: {
  OPC_CheckPredicate, 1,                     // 211:   check predicate 1
  OPC_CheckField, 4, 2, 0,                   // 213:   check Inst[5:4] == 0x0
  OPC_Decode, 198, 19, 23,                   // 217:   decode to SDBBP16_MM using decoder 23
                                             // 217:  }
  12, 0,                                     // 221:  case 0xc: {
  OPC_CheckPredicate, 1,                     // 223:   check predicate 1
  OPC_CheckField, 5, 1, 0,                   // 225:   check Inst[5] == 0x0
  OPC_Decode, 206, 14, 24,                   // 229:   decode to JRADDIUSP using decoder 24
                                             // 229:  }
                                             // 229:  } // switch Inst[9:6]
                                             // 229: }
  18, 6,                                     // 233: case 0x12: {
  OPC_CheckPredicate, 2,                     // 235:  check predicate 2
  OPC_Decode, 200, 15, 25,                   // 237:  decode to LWSP_MM using decoder 25
                                             // 237: }
  19, 19,                                    // 241: case 0x13: {
  OPC_SwitchField, 0, 1,                     // 243:  switch Inst[0] {
  0, 6,                                      // 246:  case 0x0: {
  OPC_CheckPredicate, 2,                     // 248:   check predicate 2
  OPC_Decode, 152, 6, 26,                    // 250:   decode to ADDIUS5_MM using decoder 26
                                             // 250:  }
  1, 0,                                      // 254:  case 0x1: {
  OPC_CheckPredicate, 2,                     // 256:   check predicate 2
  OPC_Decode, 153, 6, 27,                    // 258:   decode to ADDIUSP_MM using decoder 27
                                             // 258:  }
                                             // 258:  } // switch Inst[0]
                                             // 258: }
  25, 6,                                     // 262: case 0x19: {
  OPC_CheckPredicate, 2,                     // 264:  check predicate 2
  OPC_Decode, 183, 15, 28,                   // 266:  decode to LWGP_MM using decoder 28
                                             // 266: }
  26, 6,                                     // 270: case 0x1a: {
  OPC_CheckPredicate, 2,                     // 272:  check predicate 2
  OPC_Decode, 171, 15, 15,                   // 274:  decode to LW16_MM using decoder 15
                                             // 274: }
  27, 19,                                    // 278: case 0x1b: {
  OPC_SwitchField, 0, 1,                     // 280:  switch Inst[0] {
  0, 6,                                      // 283:  case 0x0: {
  OPC_CheckPredicate, 2,                     // 285:   check predicate 2
  OPC_Decode, 151, 6, 29,                    // 287:   decode to ADDIUR2_MM using decoder 29
                                             // 287:  }
  1, 0,                                      // 291:  case 0x1: {
  OPC_CheckPredicate, 2,                     // 293:   check predicate 2
  OPC_Decode, 150, 6, 30,                    // 295:   decode to ADDIUR1SP_MM using decoder 30
                                             // 295:  }
                                             // 295:  } // switch Inst[0]
                                             // 295: }
  33, 10,                                    // 299: case 0x21: {
  OPC_CheckPredicate, 1,                     // 301:  check predicate 1
  OPC_CheckField, 0, 1, 0,                   // 303:  check Inst[0] == 0x0
  OPC_Decode, 230, 16, 31,                   // 307:  decode to MOVEP_MM using decoder 31
                                             // 307: }
  34, 6,                                     // 311: case 0x22: {
  OPC_CheckPredicate, 1,                     // 313:  check predicate 1
  OPC_Decode, 179, 19, 15,                   // 315:  decode to SB16_MM using decoder 15
                                             // 315: }
  35, 6,                                     // 319: case 0x23: {
  OPC_CheckPredicate, 1,                     // 321:  check predicate 1
  OPC_Decode, 192, 7, 32,                    // 323:  decode to BEQZ16_MM using decoder 32
                                             // 323: }
  42, 6,                                     // 327: case 0x2a: {
  OPC_CheckPredicate, 1,                     // 329:  check predicate 1
  OPC_Decode, 245, 19, 15,                   // 331:  decode to SH16_MM using decoder 15
                                             // 331: }
  43, 6,                                     // 335: case 0x2b: {
  OPC_CheckPredicate, 1,                     // 337:  check predicate 1
  OPC_Decode, 167, 8, 32,                    // 339:  decode to BNEZ16_MM using decoder 32
                                             // 339: }
  50, 6,                                     // 343: case 0x32: {
  OPC_CheckPredicate, 1,                     // 345:  check predicate 1
  OPC_Decode, 234, 21, 25,                   // 347:  decode to SWSP_MM using decoder 25
                                             // 347: }
  51, 6,                                     // 351: case 0x33: {
  OPC_CheckPredicate, 2,                     // 353:  check predicate 2
  OPC_Decode, 150, 7, 33,                    // 355:  decode to B16_MM using decoder 33
                                             // 355: }
  58, 6,                                     // 359: case 0x3a: {
  OPC_CheckPredicate, 1,                     // 361:  check predicate 1
  OPC_Decode, 207, 21, 15,                   // 363:  decode to SW16_MM using decoder 15
                                             // 363: }
  59, 0,                                     // 367: case 0x3b: {
  OPC_CheckPredicate, 1,                     // 369:  check predicate 1
  OPC_Decode, 148, 15, 34,                   // 371:  decode to LI16_MM using decoder 34
                                             // 371: }
                                             // 371: } // switch Inst[15:10]
};
static const uint8_t DecoderTableMicroMipsR616[257] = {
  OPC_SwitchField, 10, 6,                    //   0: switch Inst[15:10] {
  1, 19,                                     //   3: case 0x1: {
  OPC_SwitchField, 0, 1,                     //   5:  switch Inst[0] {
  0, 6,                                      //   8:  case 0x0: {
  OPC_CheckPredicate, 3,                     //  10:   check predicate 3
  OPC_Decode, 185, 6, 35,                    //  12:   decode to ADDU16_MMR6 using decoder 35
                                             //  12:  }
  1, 0,                                      //  16:  case 0x1: {
  OPC_CheckPredicate, 3,                     //  18:   check predicate 3
  OPC_Decode, 177, 21, 35,                   //  20:   decode to SUBU16_MMR6 using decoder 35
                                             //  20:  }
                                             //  20:  } // switch Inst[0]
                                             //  20: }
  3, 6,                                      //  24: case 0x3: {
  OPC_CheckPredicate, 3,                     //  26:  check predicate 3
  OPC_Decode, 229, 16, 16,                   //  28:  decode to MOVE16_MMR6 using decoder 16
                                             //  28: }
  9, 19,                                     //  32: case 0x9: {
  OPC_SwitchField, 0, 1,                     //  34:  switch Inst[0] {
  0, 6,                                      //  37:  case 0x0: {
  OPC_CheckPredicate, 3,                     //  39:   check predicate 3
  OPC_Decode, 187, 20, 17,                   //  41:   decode to SLL16_MMR6 using decoder 17
                                             //  41:  }
  1, 0,                                      //  45:  case 0x1: {
  OPC_CheckPredicate, 3,                     //  47:   check predicate 3
  OPC_Decode, 246, 20, 17,                   //  49:   decode to SRL16_MMR6 using decoder 17
                                             //  49:  }
                                             //  49:  } // switch Inst[0]
                                             //  49: }
  11, 6,                                     //  53: case 0xb: {
  OPC_CheckPredicate, 3,                     //  55:  check predicate 3
  OPC_Decode, 230, 6, 18,                    //  57:  decode to ANDI16_MMR6 using decoder 18
                                             //  57: }
  17, 129, 1,                                //  61: case 0x11: {
  OPC_SwitchField, 2, 1,                     //  64:  switch Inst[2] {
  0, 116,                                    //  67:  case 0x0: {
  OPC_SwitchField, 0, 2,                     //  69:   switch Inst[1:0] {
  0, 19,                                     //  72:   case 0x0: {
  OPC_SwitchField, 3, 1,                     //  74:    switch Inst[3] {
  0, 6,                                      //  77:    case 0x0: {
  OPC_CheckPredicate, 3,                     //  79:     check predicate 3
  OPC_Decode, 161, 18, 36,                   //  81:     decode to NOT16_MMR6 using decoder 36
                                             //  81:    }
  1, 0,                                      //  85:    case 0x1: {
  OPC_CheckPredicate, 3,                     //  87:     check predicate 3
  OPC_Decode, 220, 22, 37,                   //  89:     decode to XOR16_MMR6 using decoder 37
                                             //  89:    }
                                             //  89:    } // switch Inst[3]
                                             //  89:   }
  1, 19,                                     //  93:   case 0x1: {
  OPC_SwitchField, 3, 1,                     //  95:    switch Inst[3] {
  0, 6,                                      //  98:    case 0x0: {
  OPC_CheckPredicate, 3,                     // 100:     check predicate 3
  OPC_Decode, 227, 6, 37,                    // 102:     decode to AND16_MMR6 using decoder 37
                                             // 102:    }
  1, 0,                                      // 106:    case 0x1: {
  OPC_CheckPredicate, 3,                     // 108:     check predicate 3
  OPC_Decode, 166, 18, 37,                   // 110:     decode to OR16_MMR6 using decoder 37
                                             // 110:    }
                                             // 110:    } // switch Inst[3]
                                             // 110:   }
  2, 19,                                     // 114:   case 0x2: {
  OPC_SwitchField, 3, 1,                     // 116:    switch Inst[3] {
  0, 6,                                      // 119:    case 0x0: {
  OPC_CheckPredicate, 3,                     // 121:     check predicate 3
  OPC_Decode, 190, 15, 21,                   // 123:     decode to LWM16_MMR6 using decoder 21
                                             // 123:    }
  1, 0,                                      // 127:    case 0x1: {
  OPC_CheckPredicate, 3,                     // 129:     check predicate 3
  OPC_Decode, 226, 21, 21,                   // 131:     decode to SWM16_MMR6 using decoder 21
                                             // 131:    }
                                             // 131:    } // switch Inst[3]
                                             // 131:   }
  3, 0,                                      // 135:   case 0x3: {
  OPC_SwitchField, 3, 2,                     // 137:    switch Inst[4:3] {
  0, 6,                                      // 140:    case 0x0: {
  OPC_CheckPredicate, 3,                     // 142:     check predicate 3
  OPC_Decode, 208, 14, 38,                   // 144:     decode to JRC16_MMR6 using decoder 38
                                             // 144:    }
  1, 6,                                      // 148:    case 0x1: {
  OPC_CheckPredicate, 3,                     // 150:     check predicate 3
  OPC_Decode, 185, 14, 38,                   // 152:     decode to JALRC16_MMR6 using decoder 38
                                             // 152:    }
  2, 6,                                      // 156:    case 0x2: {
  OPC_CheckPredicate, 3,                     // 158:     check predicate 3
  OPC_Decode, 209, 14, 39,                   // 160:     decode to JRCADDIUSP_MMR6 using decoder 39
                                             // 160:    }
  3, 0,                                      // 164:    case 0x3: {
  OPC_SwitchField, 5, 1,                     // 166:     switch Inst[5] {
  0, 6,                                      // 169:     case 0x0: {
  OPC_CheckPredicate, 3,                     // 171:      check predicate 3
  OPC_Decode, 190, 8, 40,                    // 173:      decode to BREAK16_MMR6 using decoder 40
                                             // 173:     }
  1, 0,                                      // 177:     case 0x1: {
  OPC_CheckPredicate, 3,                     // 179:      check predicate 3
  OPC_Decode, 199, 19, 40,                   // 181:      decode to SDBBP16_MMR6 using decoder 40
                                             // 181:     }
                                             // 181:     } // switch Inst[5]
                                             // 181:    }
                                             // 181:    } // switch Inst[4:3]
                                             // 181:   }
                                             // 181:   } // switch Inst[1:0]
                                             // 181:  }
  1, 0,                                      // 185:  case 0x1: {
  OPC_CheckPredicate, 3,                     // 187:   check predicate 3
  OPC_Decode, 231, 16, 31,                   // 189:   decode to MOVEP_MMR6 using decoder 31
                                             // 189:  }
                                             // 189:  } // switch Inst[2]
                                             // 189: }
  34, 6,                                     // 193: case 0x22: {
  OPC_CheckPredicate, 3,                     // 195:  check predicate 3
  OPC_Decode, 180, 19, 15,                   // 197:  decode to SB16_MMR6 using decoder 15
                                             // 197: }
  35, 6,                                     // 201: case 0x23: {
  OPC_CheckPredicate, 3,                     // 203:  check predicate 3
  OPC_Decode, 196, 7, 32,                    // 205:  decode to BEQZC16_MMR6 using decoder 32
                                             // 205: }
  42, 6,                                     // 209: case 0x2a: {
  OPC_CheckPredicate, 3,                     // 211:  check predicate 3
  OPC_Decode, 246, 19, 15,                   // 213:  decode to SH16_MMR6 using decoder 15
                                             // 213: }
  43, 6,                                     // 217: case 0x2b: {
  OPC_CheckPredicate, 3,                     // 219:  check predicate 3
  OPC_Decode, 171, 8, 32,                    // 221:  decode to BNEZC16_MMR6 using decoder 32
                                             // 221: }
  50, 6,                                     // 225: case 0x32: {
  OPC_CheckPredicate, 3,                     // 227:  check predicate 3
  OPC_Decode, 235, 21, 25,                   // 229:  decode to SWSP_MMR6 using decoder 25
                                             // 229: }
  51, 6,                                     // 233: case 0x33: {
  OPC_CheckPredicate, 3,                     // 235:  check predicate 3
  OPC_Decode, 162, 7, 33,                    // 237:  decode to BC16_MMR6 using decoder 33
                                             // 237: }
  58, 6,                                     // 241: case 0x3a: {
  OPC_CheckPredicate, 3,                     // 243:  check predicate 3
  OPC_Decode, 208, 21, 15,                   // 245:  decode to SW16_MMR6 using decoder 15
                                             // 245: }
  59, 0,                                     // 249: case 0x3b: {
  OPC_CheckPredicate, 3,                     // 251:  check predicate 3
  OPC_Decode, 149, 15, 34,                   // 253:  decode to LI16_MMR6 using decoder 34
                                             // 253: }
                                             // 253: } // switch Inst[15:10]
};
static const uint8_t DecoderTable32[305] = {
  OPC_SwitchField, 11, 5,                    //   0: switch Inst[15:11] {
  1, 14,                                     //   3: case 0x1: {
  OPC_CheckPredicate, 0,                     //   5:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 //   7:  check Inst[31:27] == 0x1e
  OPC_CheckField, 5, 3, 0,                   //  11:  check Inst[7:5] == 0x0
  OPC_Decode, 142, 7, 41,                    //  15:  decode to AddiuRxPcImmX16 using decoder 41
                                             //  15: }
  2, 14,                                     //  19: case 0x2: {
  OPC_CheckPredicate, 0,                     //  21:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 //  23:  check Inst[31:27] == 0x1e
  OPC_CheckField, 5, 6, 0,                   //  27:  check Inst[10:5] == 0x0
  OPC_Decode, 211, 8, 42,                    //  31:  decode to BimmX16 using decoder 42
                                             //  31: }
  4, 14,                                     //  35: case 0x4: {
  OPC_CheckPredicate, 0,                     //  37:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 //  39:  check Inst[31:27] == 0x1e
  OPC_CheckField, 5, 3, 0,                   //  43:  check Inst[7:5] == 0x0
  OPC_Decode, 209, 8, 43,                    //  47:  decode to BeqzRxImmX16 using decoder 43
                                             //  47: }
  5, 14,                                     //  51: case 0x5: {
  OPC_CheckPredicate, 0,                     //  53:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 //  55:  check Inst[31:27] == 0x1e
  OPC_CheckField, 5, 3, 0,                   //  59:  check Inst[7:5] == 0x0
  OPC_Decode, 213, 8, 43,                    //  63:  decode to BnezRxImmX16 using decoder 43
                                             //  63: }
  6, 64,                                     //  67: case 0x6: {
  OPC_CheckField, 27, 5, 30,                 //  69:  check Inst[31:27] == 0x1e
  OPC_Scope, 31,                             //  73:  try {
  OPC_CheckField, 16, 5, 0,                  //  75:   check Inst[20:16] == 0x0
  OPC_SwitchField, 0, 5,                     //  79:   switch Inst[4:0] {
  0, 6,                                      //  82:   case 0x0: {
  OPC_CheckPredicate, 0,                     //  84:    check predicate 0
  OPC_Decode, 254, 21, 44,                   //  86:    decode to SllX16 using decoder 44
                                             //  86:   }
  2, 6,                                      //  90:   case 0x2: {
  OPC_CheckPredicate, 0,                     //  92:    check predicate 0
  OPC_Decode, 136, 22, 44,                   //  94:    decode to SrlX16 using decoder 44
                                             //  94:   }
  3, 0,                                      //  98:   case 0x3: {
  OPC_CheckPredicate, 0,                     // 100:    check predicate 0
  OPC_Decode, 134, 22, 44,                   // 102:    decode to SraX16 using decoder 44
                                             // 102:   }
                                             // 102:   } // switch Inst[4:0]
                                             // 102:  } else try {
  OPC_SwitchField, 5, 6,                     // 106:   switch Inst[10:5] {
  0, 6,                                      // 109:   case 0x0: {
  OPC_CheckPredicate, 0,                     // 111:    check predicate 0
  OPC_Decode, 216, 8, 45,                    // 113:    decode to BteqzX16 using decoder 45
                                             // 113:   }
  8, 6,                                      // 117:   case 0x8: {
  OPC_CheckPredicate, 0,                     // 119:    check predicate 0
  OPC_Decode, 218, 8, 45,                    // 121:    decode to BtnezX16 using decoder 45
                                             // 121:   }
  24, 0,                                     // 125:   case 0x18: {
  OPC_CheckPredicate, 0,                     // 127:    check predicate 0
  OPC_Decode, 147, 7, 45,                    // 129:    decode to AddiuSpImmX16 using decoder 45
                                             // 129:   }
                                             // 129:   } // switch Inst[10:5]
                                             // 129:  }
                                             // 129: }
  8, 14,                                     // 133: case 0x8: {
  OPC_CheckPredicate, 0,                     // 135:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 137:  check Inst[31:27] == 0x1e
  OPC_CheckField, 4, 1, 0,                   // 141:  check Inst[4] == 0x0
  OPC_Decode, 145, 7, 46,                    // 145:  decode to AddiuRxRyOffMemX16 using decoder 46
                                             // 145: }
  9, 14,                                     // 149: case 0x9: {
  OPC_CheckPredicate, 0,                     // 151:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 153:  check Inst[31:27] == 0x1e
  OPC_CheckField, 5, 3, 0,                   // 157:  check Inst[7:5] == 0x0
  OPC_Decode, 141, 7, 41,                    // 161:  decode to AddiuRxImmX16 using decoder 41
                                             // 161: }
  10, 14,                                    // 165: case 0xa: {
  OPC_CheckPredicate, 0,                     // 167:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 169:  check Inst[31:27] == 0x1e
  OPC_CheckField, 5, 3, 0,                   // 173:  check Inst[7:5] == 0x0
  OPC_Decode, 130, 22, 41,                   // 177:  decode to SltiRxImmX16 using decoder 41
                                             // 177: }
  11, 14,                                    // 181: case 0xb: {
  OPC_CheckPredicate, 0,                     // 183:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 185:  check Inst[31:27] == 0x1e
  OPC_CheckField, 5, 3, 0,                   // 189:  check Inst[7:5] == 0x0
  OPC_Decode, 132, 22, 41,                   // 193:  decode to SltiuRxImmX16 using decoder 41
                                             // 193: }
  13, 14,                                    // 197: case 0xd: {
  OPC_CheckPredicate, 0,                     // 199:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 201:  check Inst[31:27] == 0x1e
  OPC_CheckField, 5, 3, 0,                   // 205:  check Inst[7:5] == 0x0
  OPC_Decode, 217, 15, 41,                   // 209:  decode to LiRxImmX16 using decoder 41
                                             // 209: }
  14, 14,                                    // 213: case 0xe: {
  OPC_CheckPredicate, 0,                     // 215:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 217:  check Inst[31:27] == 0x1e
  OPC_CheckField, 5, 3, 0,                   // 221:  check Inst[7:5] == 0x0
  OPC_Decode, 154, 11, 41,                   // 225:  decode to CmpiRxImmX16 using decoder 41
                                             // 225: }
  18, 10,                                    // 229: case 0x12: {
  OPC_CheckPredicate, 0,                     // 231:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 233:  check Inst[31:27] == 0x1e
  OPC_Decode, 221, 15, 46,                   // 237:  decode to LwRxSpImmX16 using decoder 46
                                             // 237: }
  22, 14,                                    // 241: case 0x16: {
  OPC_CheckPredicate, 0,                     // 243:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 245:  check Inst[31:27] == 0x1e
  OPC_CheckField, 5, 3, 0,                   // 249:  check Inst[7:5] == 0x0
  OPC_Decode, 219, 15, 47,                   // 253:  decode to LwRxPcTcpX16 using decoder 47
                                             // 253: }
  24, 10,                                    // 257: case 0x18: {
  OPC_CheckPredicate, 0,                     // 259:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 261:  check Inst[31:27] == 0x1e
  OPC_Decode, 250, 21, 46,                   // 265:  decode to SbRxRyOffMemX16 using decoder 46
                                             // 265: }
  25, 10,                                    // 269: case 0x19: {
  OPC_CheckPredicate, 0,                     // 271:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 273:  check Inst[31:27] == 0x1e
  OPC_Decode, 253, 21, 46,                   // 277:  decode to ShRxRyOffMemX16 using decoder 46
                                             // 277: }
  26, 10,                                    // 281: case 0x1a: {
  OPC_CheckPredicate, 0,                     // 283:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 285:  check Inst[31:27] == 0x1e
  OPC_Decode, 140, 22, 46,                   // 289:  decode to SwRxSpImmX16 using decoder 46
                                             // 289: }
  27, 0,                                     // 293: case 0x1b: {
  OPC_CheckPredicate, 0,                     // 295:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 297:  check Inst[31:27] == 0x1e
  OPC_Decode, 139, 22, 46,                   // 301:  decode to SwRxRyOffMemX16 using decoder 46
                                             // 301: }
                                             // 301: } // switch Inst[15:11]
};
static const uint8_t DecoderTableCOP3_32[35] = {
  OPC_SwitchField, 26, 6,                    //  0: switch Inst[31:26] {
  51, 6,                                     //  3: case 0x33: {
  OPC_CheckPredicate, 4,                     //  5:  check predicate 4
  OPC_Decode, 178, 15, 48,                   //  7:  decode to LWC3 using decoder 48
                                             //  7: }
  55, 6,                                     // 11: case 0x37: {
  OPC_CheckPredicate, 5,                     // 13:  check predicate 5
  OPC_Decode, 246, 14, 48,                   // 15:  decode to LDC3 using decoder 48
                                             // 15: }
  59, 6,                                     // 19: case 0x3b: {
  OPC_CheckPredicate, 4,                     // 21:  check predicate 4
  OPC_Decode, 215, 21, 48,                   // 23:  decode to SWC3 using decoder 48
                                             // 23: }
  63, 0,                                     // 27: case 0x3f: {
  OPC_CheckPredicate, 5,                     // 29:  check predicate 5
  OPC_Decode, 211, 19, 48,                   // 31:  decode to SDC3 using decoder 48
                                             // 31: }
                                             // 31: } // switch Inst[31:26]
};
static const uint8_t DecoderTableCnMips32[298] = {
  OPC_SwitchField, 26, 6,                    //   0: switch Inst[31:26] {
  18, 19,                                    //   3: case 0x12: {
  OPC_SwitchField, 21, 5,                    //   5:  switch Inst[25:21] {
  1, 6,                                      //   8:  case 0x1: {
  OPC_CheckPredicate, 6,                     //  10:   check predicate 6
  OPC_Decode, 200, 11, 49,                   //  12:   decode to DMFC2_OCTEON using decoder 49
                                             //  12:  }
  5, 0,                                      //  16:  case 0x5: {
  OPC_CheckPredicate, 6,                     //  18:   check predicate 6
  OPC_Decode, 208, 11, 49,                   //  20:   decode to DMTC2_OCTEON using decoder 49
                                             //  20:  }
                                             //  20:  } // switch Inst[25:21]
                                             //  20: }
  28, 239, 1,                                //  24: case 0x1c: {
  OPC_SwitchField, 0, 6,                     //  27:  switch Inst[5:0] {
  3, 10,                                     //  30:  case 0x3: {
  OPC_CheckPredicate, 6,                     //  32:   check predicate 6
  OPC_CheckField, 6, 5, 0,                   //  34:   check Inst[10:6] == 0x0
  OPC_Decode, 212, 11, 50,                   //  38:   decode to DMUL using decoder 50
                                             //  38:  }
  8, 10,                                     //  42:  case 0x8: {
  OPC_CheckPredicate, 6,                     //  44:   check predicate 6
  OPC_CheckField, 6, 15, 0,                  //  46:   check Inst[20:6] == 0x0
  OPC_Decode, 201, 17, 51,                   //  50:   decode to MTM0 using decoder 51
                                             //  50:  }
  9, 10,                                     //  54:  case 0x9: {
  OPC_CheckPredicate, 6,                     //  56:   check predicate 6
  OPC_CheckField, 6, 15, 0,                  //  58:   check Inst[20:6] == 0x0
  OPC_Decode, 204, 17, 51,                   //  62:   decode to MTP0 using decoder 51
                                             //  62:  }
  10, 10,                                    //  66:  case 0xa: {
  OPC_CheckPredicate, 6,                     //  68:   check predicate 6
  OPC_CheckField, 6, 15, 0,                  //  70:   check Inst[20:6] == 0x0
  OPC_Decode, 205, 17, 51,                   //  74:   decode to MTP1 using decoder 51
                                             //  74:  }
  11, 10,                                    //  78:  case 0xb: {
  OPC_CheckPredicate, 6,                     //  80:   check predicate 6
  OPC_CheckField, 6, 15, 0,                  //  82:   check Inst[20:6] == 0x0
  OPC_Decode, 206, 17, 51,                   //  86:   decode to MTP2 using decoder 51
                                             //  86:  }
  12, 10,                                    //  90:  case 0xc: {
  OPC_CheckPredicate, 6,                     //  92:   check predicate 6
  OPC_CheckField, 6, 15, 0,                  //  94:   check Inst[20:6] == 0x0
  OPC_Decode, 202, 17, 51,                   //  98:   decode to MTM1 using decoder 51
                                             //  98:  }
  13, 10,                                    // 102:  case 0xd: {
  OPC_CheckPredicate, 6,                     // 104:   check predicate 6
  OPC_CheckField, 6, 15, 0,                  // 106:   check Inst[20:6] == 0x0
  OPC_Decode, 203, 17, 51,                   // 110:   decode to MTM2 using decoder 51
                                             // 110:  }
  15, 10,                                    // 114:  case 0xf: {
  OPC_CheckPredicate, 6,                     // 116:   check predicate 6
  OPC_CheckField, 6, 5, 0,                   // 118:   check Inst[10:6] == 0x0
  OPC_Decode, 204, 22, 50,                   // 122:   decode to VMULU using decoder 50
                                             // 122:  }
  16, 10,                                    // 126:  case 0x10: {
  OPC_CheckPredicate, 6,                     // 128:   check predicate 6
  OPC_CheckField, 6, 5, 0,                   // 130:   check Inst[10:6] == 0x0
  OPC_Decode, 203, 22, 50,                   // 134:   decode to VMM0 using decoder 50
                                             // 134:  }
  17, 10,                                    // 138:  case 0x11: {
  OPC_CheckPredicate, 6,                     // 140:   check predicate 6
  OPC_CheckField, 6, 5, 0,                   // 142:   check Inst[10:6] == 0x0
  OPC_Decode, 202, 22, 50,                   // 146:   decode to V3MULU using decoder 50
                                             // 146:  }
  40, 10,                                    // 150:  case 0x28: {
  OPC_CheckPredicate, 6,                     // 152:   check predicate 6
  OPC_CheckField, 6, 5, 0,                   // 154:   check Inst[10:6] == 0x0
  OPC_Decode, 151, 7, 50,                    // 158:   decode to BADDu using decoder 50
                                             // 158:  }
  42, 10,                                    // 162:  case 0x2a: {
  OPC_CheckPredicate, 6,                     // 164:   check predicate 6
  OPC_CheckField, 6, 5, 0,                   // 166:   check Inst[10:6] == 0x0
  OPC_Decode, 242, 19, 50,                   // 170:   decode to SEQ using decoder 50
                                             // 170:  }
  43, 10,                                    // 174:  case 0x2b: {
  OPC_CheckPredicate, 6,                     // 176:   check predicate 6
  OPC_CheckField, 6, 5, 0,                   // 178:   check Inst[10:6] == 0x0
  OPC_Decode, 214, 20, 50,                   // 182:   decode to SNE using decoder 50
                                             // 182:  }
  44, 14,                                    // 186:  case 0x2c: {
  OPC_CheckPredicate, 6,                     // 188:   check predicate 6
  OPC_CheckField, 16, 5, 0,                  // 190:   check Inst[20:16] == 0x0
  OPC_CheckField, 6, 5, 0,                   // 194:   check Inst[10:6] == 0x0
  OPC_Decode, 200, 18, 52,                   // 198:   decode to POP using decoder 52
                                             // 198:  }
  45, 14,                                    // 202:  case 0x2d: {
  OPC_CheckPredicate, 6,                     // 204:   check predicate 6
  OPC_CheckField, 16, 5, 0,                  // 206:   check Inst[20:16] == 0x0
  OPC_CheckField, 6, 5, 0,                   // 210:   check Inst[10:6] == 0x0
  OPC_Decode, 245, 11, 53,                   // 214:   decode to DPOP using decoder 53
                                             // 214:  }
  46, 6,                                     // 218:  case 0x2e: {
  OPC_CheckPredicate, 6,                     // 220:   check predicate 6
  OPC_Decode, 243, 19, 54,                   // 222:   decode to SEQi using decoder 54
                                             // 222:  }
  47, 6,                                     // 226:  case 0x2f: {
  OPC_CheckPredicate, 6,                     // 228:   check predicate 6
  OPC_Decode, 215, 20, 54,                   // 230:   decode to SNEi using decoder 54
                                             // 230:  }
  50, 6,                                     // 234:  case 0x32: {
  OPC_CheckPredicate, 7,                     // 236:   check predicate 7
  OPC_Decode, 248, 8, 55,                    // 238:   decode to CINS using decoder 55
                                             // 238:  }
  51, 6,                                     // 242:  case 0x33: {
  OPC_CheckPredicate, 7,                     // 244:   check predicate 7
  OPC_Decode, 249, 8, 55,                    // 246:   decode to CINS32 using decoder 55
                                             // 246:  }
  58, 6,                                     // 250:  case 0x3a: {
  OPC_CheckPredicate, 7,                     // 252:   check predicate 7
  OPC_Decode, 204, 12, 55,                   // 254:   decode to EXTS using decoder 55
                                             // 254:  }
  59, 0,                                     // 258:  case 0x3b: {
  OPC_CheckPredicate, 7,                     // 260:   check predicate 7
  OPC_Decode, 205, 12, 55,                   // 262:   decode to EXTS32 using decoder 55
                                             // 262:  }
                                             // 262:  } // switch Inst[5:0]
                                             // 262: }
  50, 6,                                     // 266: case 0x32: {
  OPC_CheckPredicate, 6,                     // 268:  check predicate 6
  OPC_Decode, 157, 7, 56,                    // 270:  decode to BBIT0 using decoder 56
                                             // 270: }
  54, 6,                                     // 274: case 0x36: {
  OPC_CheckPredicate, 6,                     // 276:  check predicate 6
  OPC_Decode, 158, 7, 56,                    // 278:  decode to BBIT032 using decoder 56
                                             // 278: }
  58, 6,                                     // 282: case 0x3a: {
  OPC_CheckPredicate, 6,                     // 284:  check predicate 6
  OPC_Decode, 159, 7, 56,                    // 286:  decode to BBIT1 using decoder 56
                                             // 286: }
  62, 0,                                     // 290: case 0x3e: {
  OPC_CheckPredicate, 6,                     // 292:  check predicate 6
  OPC_Decode, 160, 7, 56,                    // 294:  decode to BBIT132 using decoder 56
                                             // 294: }
                                             // 294: } // switch Inst[31:26]
};
static const uint8_t DecoderTableCnMipsP32[27] = {
  OPC_SwitchField, 0, 16,                    //  0: switch Inst[15:0] {
  24, 10,                                    //  3: case 0x18: {
  OPC_CheckPredicate, 8,                     //  5:  check predicate 8
  OPC_CheckField, 26, 6, 28,                 //  7:  check Inst[31:26] == 0x1c
  OPC_Decode, 168, 19, 57,                   // 11:  decode to SAA using decoder 57
                                             // 11: }
  25, 0,                                     // 15: case 0x19: {
  OPC_CheckPredicate, 8,                     // 17:  check predicate 8
  OPC_CheckField, 26, 6, 28,                 // 19:  check Inst[31:26] == 0x1c
  OPC_Decode, 169, 19, 57,                   // 23:  decode to SAAD using decoder 57
                                             // 23: }
                                             // 23: } // switch Inst[15:0]
};
static const uint8_t DecoderTableMicroMips32[3850] = {
  OPC_SwitchField, 26, 6,                    //    0: switch Inst[31:26] {
  0, 162, 17,                                //    3: case 0x0: {
  OPC_SwitchField, 0, 6,                     //    6:  switch Inst[5:0] {
  0, 64,                                     //    9:  case 0x0: {
  OPC_SwitchField, 6, 5,                     //   11:   switch Inst[10:6] {
  0, 35,                                     //   14:   case 0x0: {
  OPC_Scope, 27,                             //   16:    try {
  OPC_SwitchField, 11, 15,                   //   18:     switch Inst[25:11] {
  1, 6,                                      //   21:     case 0x1: {
  OPC_CheckPredicate, 2,                     //   23:      check predicate 2
  OPC_Decode, 139, 21, 10,                   //   25:      decode to SSNOP_MM using decoder 10
                                             //   25:     }
  3, 6,                                      //   29:     case 0x3: {
  OPC_CheckPredicate, 2,                     //   31:      check predicate 2
  OPC_Decode, 165, 12, 10,                   //   33:      decode to EHB_MM using decoder 10
                                             //   33:     }
  5, 0,                                      //   37:     case 0x5: {
  OPC_CheckPredicate, 2,                     //   39:      check predicate 2
  OPC_Decode, 180, 18, 10,                   //   41:      decode to PAUSE_MM using decoder 10
                                             //   41:     }
                                             //   41:     } // switch Inst[25:11]
                                             //   41:    } else try {
  OPC_CheckPredicate, 2,                     //   45:     check predicate 2
  OPC_Decode, 199, 20, 58,                   //   47:     decode to SLL_MM using decoder 58
                                             //   47:    }
                                             //   47:   }
  1, 6,                                      //   51:   case 0x1: {
  OPC_CheckPredicate, 2,                     //   53:    check predicate 2
  OPC_Decode, 136, 21, 58,                   //   55:    decode to SRL_MM using decoder 58
                                             //   55:   }
  2, 6,                                      //   59:   case 0x2: {
  OPC_CheckPredicate, 2,                     //   61:    check predicate 2
  OPC_Decode, 242, 20, 58,                   //   63:    decode to SRA_MM using decoder 58
                                             //   63:   }
  3, 0,                                      //   67:   case 0x3: {
  OPC_CheckPredicate, 2,                     //   69:    check predicate 2
  OPC_Decode, 148, 19, 58,                   //   71:    decode to ROTR_MM using decoder 58
                                             //   71:   }
                                             //   71:   } // switch Inst[10:6]
                                             //   71:  }
  5, 131, 1,                                 //   75:  case 0x5: {
  OPC_SwitchField, 6, 5,                     //   78:   switch Inst[10:6] {
  0, 10,                                     //   81:   case 0x0: {
  OPC_CheckPredicate, 9,                     //   83:    check predicate 9
  OPC_CheckField, 11, 5, 0,                  //   85:    check Inst[15:11] == 0x0
  OPC_Decode, 191, 9, 59,                    //   89:    decode to CMP_EQ_PH_MM using decoder 59
                                             //   89:   }
  1, 10,                                     //   93:   case 0x1: {
  OPC_CheckPredicate, 9,                     //   95:    check predicate 9
  OPC_CheckField, 11, 5, 0,                  //   97:    check Inst[15:11] == 0x0
  OPC_Decode, 205, 9, 59,                    //  101:    decode to CMP_LT_PH_MM using decoder 59
                                             //  101:   }
  2, 10,                                     //  105:   case 0x2: {
  OPC_CheckPredicate, 9,                     //  107:    check predicate 9
  OPC_CheckField, 11, 5, 0,                  //  109:    check Inst[15:11] == 0x0
  OPC_Decode, 199, 9, 59,                    //  113:    decode to CMP_LE_PH_MM using decoder 59
                                             //  113:   }
  6, 6,                                      //  117:   case 0x6: {
  OPC_CheckPredicate, 10,                    //  119:    check predicate 10
  OPC_Decode, 169, 9, 60,                    //  121:    decode to CMPGDU_EQ_QB_MMR2 using decoder 60
                                             //  121:   }
  7, 6,                                      //  125:   case 0x7: {
  OPC_CheckPredicate, 10,                    //  127:    check predicate 10
  OPC_Decode, 173, 9, 60,                    //  129:    decode to CMPGDU_LT_QB_MMR2 using decoder 60
                                             //  129:   }
  8, 6,                                      //  133:   case 0x8: {
  OPC_CheckPredicate, 10,                    //  135:    check predicate 10
  OPC_Decode, 171, 9, 60,                    //  137:    decode to CMPGDU_LE_QB_MMR2 using decoder 60
                                             //  137:   }
  9, 10,                                     //  141:   case 0x9: {
  OPC_CheckPredicate, 9,                     //  143:    check predicate 9
  OPC_CheckField, 11, 5, 0,                  //  145:    check Inst[15:11] == 0x0
  OPC_Decode, 181, 9, 59,                    //  149:    decode to CMPU_EQ_QB_MM using decoder 59
                                             //  149:   }
  10, 10,                                    //  153:   case 0xa: {
  OPC_CheckPredicate, 9,                     //  155:    check predicate 9
  OPC_CheckField, 11, 5, 0,                  //  157:    check Inst[15:11] == 0x0
  OPC_Decode, 185, 9, 59,                    //  161:    decode to CMPU_LT_QB_MM using decoder 59
                                             //  161:   }
  11, 10,                                    //  165:   case 0xb: {
  OPC_CheckPredicate, 9,                     //  167:    check predicate 9
  OPC_CheckField, 11, 5, 0,                  //  169:    check Inst[15:11] == 0x0
  OPC_Decode, 183, 9, 59,                    //  173:    decode to CMPU_LE_QB_MM using decoder 59
                                             //  173:   }
  12, 6,                                     //  177:   case 0xc: {
  OPC_CheckPredicate, 9,                     //  179:    check predicate 9
  OPC_Decode, 168, 6, 61,                    //  181:    decode to ADDQ_S_W_MM using decoder 61
                                             //  181:   }
  13, 6,                                     //  185:   case 0xd: {
  OPC_CheckPredicate, 9,                     //  187:    check predicate 9
  OPC_Decode, 159, 21, 61,                   //  189:    decode to SUBQ_S_W_MM using decoder 61
                                             //  189:   }
  14, 6,                                     //  193:   case 0xe: {
  OPC_CheckPredicate, 9,                     //  195:    check predicate 9
  OPC_Decode, 171, 6, 61,                    //  197:    decode to ADDSC_MM using decoder 61
                                             //  197:   }
  15, 0,                                     //  201:   case 0xf: {
  OPC_CheckPredicate, 9,                     //  203:    check predicate 9
  OPC_Decode, 208, 6, 61,                    //  205:    decode to ADDWC_MM using decoder 61
                                             //  205:   }
                                             //  205:   } // switch Inst[10:6]
                                             //  205:  }
  7, 6,                                      //  209:  case 0x7: {
  OPC_CheckPredicate, 2,                     //  211:   check predicate 2
  OPC_Decode, 191, 8, 62,                    //  213:   decode to BREAK_MM using decoder 62
                                             //  213:  }
  12, 6,                                     //  217:  case 0xc: {
  OPC_CheckPredicate, 1,                     //  219:   check predicate 1
  OPC_Decode, 178, 14, 63,                   //  221:   decode to INS_MM using decoder 63
                                             //  221:  }
  13, 243, 1,                                //  225:  case 0xd: {
  OPC_SwitchField, 6, 5,                     //  228:   switch Inst[10:6] {
  0, 6,                                      //  231:   case 0x0: {
  OPC_CheckPredicate, 9,                     //  233:    check predicate 9
  OPC_Decode, 164, 6, 64,                    //  235:    decode to ADDQ_PH_MM using decoder 64
                                             //  235:   }
  1, 6,                                      //  239:   case 0x1: {
  OPC_CheckPredicate, 10,                    //  241:    check predicate 10
  OPC_Decode, 156, 6, 64,                    //  243:    decode to ADDQH_PH_MMR2 using decoder 64
                                             //  243:   }
  2, 6,                                      //  247:   case 0x2: {
  OPC_CheckPredicate, 10,                    //  249:    check predicate 10
  OPC_Decode, 162, 6, 61,                    //  251:    decode to ADDQH_W_MMR2 using decoder 61
                                             //  251:   }
  3, 6,                                      //  255:   case 0x3: {
  OPC_CheckPredicate, 9,                     //  257:    check predicate 9
  OPC_Decode, 194, 6, 64,                    //  259:    decode to ADDU_QB_MM using decoder 64
                                             //  259:   }
  4, 6,                                      //  263:   case 0x4: {
  OPC_CheckPredicate, 10,                    //  265:    check predicate 10
  OPC_Decode, 192, 6, 64,                    //  267:    decode to ADDU_PH_MMR2 using decoder 64
                                             //  267:   }
  5, 6,                                      //  271:   case 0x5: {
  OPC_CheckPredicate, 10,                    //  273:    check predicate 10
  OPC_Decode, 187, 6, 64,                    //  275:    decode to ADDUH_QB_MMR2 using decoder 64
                                             //  275:   }
  6, 6,                                      //  279:   case 0x6: {
  OPC_CheckPredicate, 9,                     //  281:    check predicate 9
  OPC_Decode, 146, 20, 65,                   //  283:    decode to SHRAV_PH_MM using decoder 65
                                             //  283:   }
  7, 6,                                      //  287:   case 0x7: {
  OPC_CheckPredicate, 10,                    //  289:    check predicate 10
  OPC_Decode, 148, 20, 65,                   //  291:    decode to SHRAV_QB_MMR2 using decoder 65
                                             //  291:   }
  8, 6,                                      //  295:   case 0x8: {
  OPC_CheckPredicate, 9,                     //  297:    check predicate 9
  OPC_Decode, 155, 21, 64,                   //  299:    decode to SUBQ_PH_MM using decoder 64
                                             //  299:   }
  9, 6,                                      //  303:   case 0x9: {
  OPC_CheckPredicate, 10,                    //  305:    check predicate 10
  OPC_Decode, 147, 21, 64,                   //  307:    decode to SUBQH_PH_MMR2 using decoder 64
                                             //  307:   }
  10, 6,                                     //  311:   case 0xa: {
  OPC_CheckPredicate, 10,                    //  313:    check predicate 10
  OPC_Decode, 153, 21, 61,                   //  315:    decode to SUBQH_W_MMR2 using decoder 61
                                             //  315:   }
  11, 6,                                     //  319:   case 0xb: {
  OPC_CheckPredicate, 9,                     //  321:    check predicate 9
  OPC_Decode, 186, 21, 64,                   //  323:    decode to SUBU_QB_MM using decoder 64
                                             //  323:   }
  12, 6,                                     //  327:   case 0xc: {
  OPC_CheckPredicate, 10,                    //  329:    check predicate 10
  OPC_Decode, 184, 21, 64,                   //  331:    decode to SUBU_PH_MMR2 using decoder 64
                                             //  331:   }
  13, 6,                                     //  335:   case 0xd: {
  OPC_CheckPredicate, 10,                    //  337:    check predicate 10
  OPC_Decode, 179, 21, 64,                   //  339:    decode to SUBUH_QB_MMR2 using decoder 64
                                             //  339:   }
  15, 6,                                     //  343:   case 0xf: {
  OPC_CheckPredicate, 10,                    //  345:    check predicate 10
  OPC_Decode, 232, 18, 66,                   //  347:    decode to PRECR_SRA_PH_W_MMR2 using decoder 66
                                             //  347:   }
  16, 6,                                     //  351:   case 0x10: {
  OPC_CheckPredicate, 9,                     //  353:    check predicate 9
  OPC_Decode, 166, 6, 64,                    //  355:    decode to ADDQ_S_PH_MM using decoder 64
                                             //  355:   }
  17, 6,                                     //  359:   case 0x11: {
  OPC_CheckPredicate, 10,                    //  361:    check predicate 10
  OPC_Decode, 158, 6, 64,                    //  363:    decode to ADDQH_R_PH_MMR2 using decoder 64
                                             //  363:   }
  18, 6,                                     //  367:   case 0x12: {
  OPC_CheckPredicate, 10,                    //  369:    check predicate 10
  OPC_Decode, 160, 6, 61,                    //  371:    decode to ADDQH_R_W_MMR2 using decoder 61
                                             //  371:   }
  19, 6,                                     //  375:   case 0x13: {
  OPC_CheckPredicate, 9,                     //  377:    check predicate 9
  OPC_Decode, 198, 6, 64,                    //  379:    decode to ADDU_S_QB_MM using decoder 64
                                             //  379:   }
  20, 6,                                     //  383:   case 0x14: {
  OPC_CheckPredicate, 10,                    //  385:    check predicate 10
  OPC_Decode, 196, 6, 64,                    //  387:    decode to ADDU_S_PH_MMR2 using decoder 64
                                             //  387:   }
  21, 6,                                     //  391:   case 0x15: {
  OPC_CheckPredicate, 10,                    //  393:    check predicate 10
  OPC_Decode, 189, 6, 64,                    //  395:    decode to ADDUH_R_QB_MMR2 using decoder 64
                                             //  395:   }
  22, 6,                                     //  399:   case 0x16: {
  OPC_CheckPredicate, 9,                     //  401:    check predicate 9
  OPC_Decode, 150, 20, 65,                   //  403:    decode to SHRAV_R_PH_MM using decoder 65
                                             //  403:   }
  23, 6,                                     //  407:   case 0x17: {
  OPC_CheckPredicate, 10,                    //  409:    check predicate 10
  OPC_Decode, 152, 20, 65,                   //  411:    decode to SHRAV_R_QB_MMR2 using decoder 65
                                             //  411:   }
  24, 6,                                     //  415:   case 0x18: {
  OPC_CheckPredicate, 9,                     //  417:    check predicate 9
  OPC_Decode, 157, 21, 64,                   //  419:    decode to SUBQ_S_PH_MM using decoder 64
                                             //  419:   }
  25, 6,                                     //  423:   case 0x19: {
  OPC_CheckPredicate, 10,                    //  425:    check predicate 10
  OPC_Decode, 149, 21, 64,                   //  427:    decode to SUBQH_R_PH_MMR2 using decoder 64
                                             //  427:   }
  26, 6,                                     //  431:   case 0x1a: {
  OPC_CheckPredicate, 10,                    //  433:    check predicate 10
  OPC_Decode, 151, 21, 61,                   //  435:    decode to SUBQH_R_W_MMR2 using decoder 61
                                             //  435:   }
  27, 6,                                     //  439:   case 0x1b: {
  OPC_CheckPredicate, 9,                     //  441:    check predicate 9
  OPC_Decode, 190, 21, 64,                   //  443:    decode to SUBU_S_QB_MM using decoder 64
                                             //  443:   }
  28, 6,                                     //  447:   case 0x1c: {
  OPC_CheckPredicate, 10,                    //  449:    check predicate 10
  OPC_Decode, 188, 21, 64,                   //  451:    decode to SUBU_S_PH_MMR2 using decoder 64
                                             //  451:   }
  29, 6,                                     //  455:   case 0x1d: {
  OPC_CheckPredicate, 10,                    //  457:    check predicate 10
  OPC_Decode, 181, 21, 64,                   //  459:    decode to SUBUH_R_QB_MMR2 using decoder 64
                                             //  459:   }
  31, 0,                                     //  463:   case 0x1f: {
  OPC_CheckPredicate, 10,                    //  465:    check predicate 10
  OPC_Decode, 234, 18, 66,                   //  467:    decode to PRECR_SRA_R_PH_W_MMR2 using decoder 66
                                             //  467:   }
                                             //  467:   } // switch Inst[10:6]
                                             //  467:  }
  14, 19,                                    //  471:  case 0xe: {
  OPC_SwitchField, 6, 5,                     //  473:   switch Inst[10:6] {
  0, 6,                                      //  476:   case 0x0: {
  OPC_CheckPredicate, 9,                     //  478:    check predicate 9
  OPC_Decode, 130, 20, 65,                   //  480:    decode to SHLLV_PH_MM using decoder 65
                                             //  480:   }
  16, 0,                                     //  484:   case 0x10: {
  OPC_CheckPredicate, 9,                     //  486:    check predicate 9
  OPC_Decode, 134, 20, 65,                   //  488:    decode to SHLLV_S_PH_MM using decoder 65
                                             //  488:   }
                                             //  488:   } // switch Inst[10:6]
                                             //  488:  }
  16, 123,                                   //  492:  case 0x10: {
  OPC_SwitchField, 6, 5,                     //  494:   switch Inst[10:6] {
  0, 6,                                      //  497:   case 0x0: {
  OPC_CheckPredicate, 2,                     //  499:    check predicate 2
  OPC_Decode, 195, 20, 67,                   //  501:    decode to SLLV_MM using decoder 67
                                             //  501:   }
  1, 6,                                      //  505:   case 0x1: {
  OPC_CheckPredicate, 2,                     //  507:    check predicate 2
  OPC_Decode, 132, 21, 67,                   //  509:    decode to SRLV_MM using decoder 67
                                             //  509:   }
  2, 6,                                      //  513:   case 0x2: {
  OPC_CheckPredicate, 2,                     //  515:    check predicate 2
  OPC_Decode, 238, 20, 67,                   //  517:    decode to SRAV_MM using decoder 67
                                             //  517:   }
  3, 6,                                      //  521:   case 0x3: {
  OPC_CheckPredicate, 2,                     //  523:    check predicate 2
  OPC_Decode, 147, 19, 67,                   //  525:    decode to ROTRV_MM using decoder 67
                                             //  525:   }
  4, 6,                                      //  529:   case 0x4: {
  OPC_CheckPredicate, 1,                     //  531:    check predicate 1
  OPC_Decode, 213, 6, 61,                    //  533:    decode to ADD_MM using decoder 61
                                             //  533:   }
  5, 6,                                      //  537:   case 0x5: {
  OPC_CheckPredicate, 1,                     //  539:    check predicate 1
  OPC_Decode, 220, 6, 61,                    //  541:    decode to ADDu_MM using decoder 61
                                             //  541:   }
  6, 6,                                      //  545:   case 0x6: {
  OPC_CheckPredicate, 1,                     //  547:    check predicate 1
  OPC_Decode, 199, 21, 61,                   //  549:    decode to SUB_MM using decoder 61
                                             //  549:   }
  7, 6,                                      //  553:   case 0x7: {
  OPC_CheckPredicate, 1,                     //  555:    check predicate 1
  OPC_Decode, 202, 21, 61,                   //  557:    decode to SUBu_MM using decoder 61
                                             //  557:   }
  8, 6,                                      //  561:   case 0x8: {
  OPC_CheckPredicate, 1,                     //  563:    check predicate 1
  OPC_Decode, 250, 17, 61,                   //  565:    decode to MUL_MM using decoder 61
                                             //  565:   }
  9, 6,                                      //  569:   case 0x9: {
  OPC_CheckPredicate, 1,                     //  571:    check predicate 1
  OPC_Decode, 233, 6, 61,                    //  573:    decode to AND_MM using decoder 61
                                             //  573:   }
  10, 6,                                     //  577:   case 0xa: {
  OPC_CheckPredicate, 1,                     //  579:    check predicate 1
  OPC_Decode, 170, 18, 61,                   //  581:    decode to OR_MM using decoder 61
                                             //  581:   }
  11, 6,                                     //  585:   case 0xb: {
  OPC_CheckPredicate, 1,                     //  587:    check predicate 1
  OPC_Decode, 157, 18, 61,                   //  589:    decode to NOR_MM using decoder 61
                                             //  589:   }
  12, 6,                                     //  593:   case 0xc: {
  OPC_CheckPredicate, 1,                     //  595:    check predicate 1
  OPC_Decode, 224, 22, 61,                   //  597:    decode to XOR_MM using decoder 61
                                             //  597:   }
  13, 6,                                     //  601:   case 0xd: {
  OPC_CheckPredicate, 2,                     //  603:    check predicate 2
  OPC_Decode, 204, 20, 61,                   //  605:    decode to SLT_MM using decoder 61
                                             //  605:   }
  14, 0,                                     //  609:   case 0xe: {
  OPC_CheckPredicate, 2,                     //  611:    check predicate 2
  OPC_Decode, 213, 20, 61,                   //  613:    decode to SLTu_MM using decoder 61
                                             //  613:   }
                                             //  613:   } // switch Inst[10:6]
                                             //  613:  }
  21, 115,                                   //  617:  case 0x15: {
  OPC_SwitchField, 6, 5,                     //  619:   switch Inst[10:6] {
  2, 6,                                      //  622:   case 0x2: {
  OPC_CheckPredicate, 9,                     //  624:    check predicate 9
  OPC_Decode, 218, 17, 64,                   //  626:    decode to MULEU_S_PH_QBL_MM using decoder 64
                                             //  626:   }
  3, 6,                                      //  630:   case 0x3: {
  OPC_CheckPredicate, 9,                     //  632:    check predicate 9
  OPC_Decode, 220, 17, 64,                   //  634:    decode to MULEU_S_PH_QBR_MM using decoder 64
                                             //  634:   }
  4, 6,                                      //  638:   case 0x4: {
  OPC_CheckPredicate, 9,                     //  640:    check predicate 9
  OPC_Decode, 222, 17, 64,                   //  642:    decode to MULQ_RS_PH_MM using decoder 64
                                             //  642:   }
  5, 6,                                      //  646:   case 0x5: {
  OPC_CheckPredicate, 10,                    //  648:    check predicate 10
  OPC_Decode, 226, 17, 64,                   //  650:    decode to MULQ_S_PH_MMR2 using decoder 64
                                             //  650:   }
  6, 6,                                      //  654:   case 0x6: {
  OPC_CheckPredicate, 10,                    //  656:    check predicate 10
  OPC_Decode, 224, 17, 61,                   //  658:    decode to MULQ_RS_W_MMR2 using decoder 61
                                             //  658:   }
  7, 6,                                      //  662:   case 0x7: {
  OPC_CheckPredicate, 10,                    //  664:    check predicate 10
  OPC_Decode, 228, 17, 61,                   //  666:    decode to MULQ_S_W_MMR2 using decoder 61
                                             //  666:   }
  8, 6,                                      //  670:   case 0x8: {
  OPC_CheckPredicate, 10,                    //  672:    check predicate 10
  OPC_Decode, 240, 6, 68,                    //  674:    decode to APPEND_MMR2 using decoder 68
                                             //  674:   }
  9, 6,                                      //  678:   case 0x9: {
  OPC_CheckPredicate, 10,                    //  680:    check predicate 10
  OPC_Decode, 243, 18, 68,                   //  682:    decode to PREPEND_MMR2 using decoder 68
                                             //  682:   }
  10, 6,                                     //  686:   case 0xa: {
  OPC_CheckPredicate, 9,                     //  688:    check predicate 9
  OPC_Decode, 216, 16, 61,                   //  690:    decode to MODSUB_MM using decoder 61
                                             //  690:   }
  11, 6,                                     //  694:   case 0xb: {
  OPC_CheckPredicate, 9,                     //  696:    check predicate 9
  OPC_Decode, 154, 20, 67,                   //  698:    decode to SHRAV_R_W_MM using decoder 67
                                             //  698:   }
  12, 6,                                     //  702:   case 0xc: {
  OPC_CheckPredicate, 10,                    //  704:    check predicate 10
  OPC_Decode, 166, 20, 65,                   //  706:    decode to SHRLV_PH_MMR2 using decoder 65
                                             //  706:   }
  13, 6,                                     //  710:   case 0xd: {
  OPC_CheckPredicate, 9,                     //  712:    check predicate 9
  OPC_Decode, 168, 20, 65,                   //  714:    decode to SHRLV_QB_MM using decoder 65
                                             //  714:   }
  14, 6,                                     //  718:   case 0xe: {
  OPC_CheckPredicate, 9,                     //  720:    check predicate 9
  OPC_Decode, 132, 20, 65,                   //  722:    decode to SHLLV_QB_MM using decoder 65
                                             //  722:   }
  15, 0,                                     //  726:   case 0xf: {
  OPC_CheckPredicate, 9,                     //  728:    check predicate 9
  OPC_Decode, 136, 20, 67,                   //  730:    decode to SHLLV_S_W_MM using decoder 67
                                             //  730:   }
                                             //  730:   } // switch Inst[10:6]
                                             //  730:  }
  24, 27,                                    //  734:  case 0x18: {
  OPC_SwitchField, 6, 5,                     //  736:   switch Inst[10:6] {
  0, 6,                                      //  739:   case 0x0: {
  OPC_CheckPredicate, 1,                     //  741:    check predicate 1
  OPC_Decode, 250, 16, 69,                   //  743:    decode to MOVN_I_MM using decoder 69
                                             //  743:   }
  1, 6,                                      //  747:   case 0x1: {
  OPC_CheckPredicate, 1,                     //  749:    check predicate 1
  OPC_Decode, 142, 17, 69,                   //  751:    decode to MOVZ_I_MM using decoder 69
                                             //  751:   }
  4, 0,                                      //  755:   case 0x4: {
  OPC_CheckPredicate, 2,                     //  757:    check predicate 2
  OPC_Decode, 206, 15, 70,                   //  759:    decode to LWXS_MM using decoder 70
                                             //  759:   }
                                             //  759:   } // switch Inst[10:6]
                                             //  759:  }
  29, 14,                                    //  763:  case 0x1d: {
  OPC_CheckPredicate, 9,                     //  765:   check predicate 9
  OPC_CheckField, 22, 4, 0,                  //  767:   check Inst[25:22] == 0x0
  OPC_CheckField, 6, 8, 0,                   //  771:   check Inst[13:6] == 0x0
  OPC_Decode, 128, 20, 71,                   //  775:   decode to SHILO_MM using decoder 71
                                             //  775:  }
  37, 43,                                    //  779:  case 0x25: {
  OPC_SwitchField, 6, 5,                     //  781:   switch Inst[10:6] {
  0, 6,                                      //  784:   case 0x0: {
  OPC_CheckPredicate, 9,                     //  786:    check predicate 9
  OPC_Decode, 214, 17, 60,                   //  788:    decode to MULEQ_S_W_PHL_MM using decoder 60
                                             //  788:   }
  1, 6,                                      //  792:   case 0x1: {
  OPC_CheckPredicate, 9,                     //  794:    check predicate 9
  OPC_Decode, 216, 17, 60,                   //  796:    decode to MULEQ_S_W_PHR_MM using decoder 60
                                             //  796:   }
  5, 6,                                      //  800:   case 0x5: {
  OPC_CheckPredicate, 9,                     //  802:    check predicate 9
  OPC_Decode, 141, 15, 70,                   //  804:    decode to LHX_MM using decoder 70
                                             //  804:   }
  6, 6,                                      //  808:   case 0x6: {
  OPC_CheckPredicate, 9,                     //  810:    check predicate 9
  OPC_Decode, 207, 15, 70,                   //  812:    decode to LWX_MM using decoder 70
                                             //  812:   }
  8, 0,                                      //  816:   case 0x8: {
  OPC_CheckPredicate, 9,                     //  818:    check predicate 9
  OPC_Decode, 228, 14, 70,                   //  820:    decode to LBUX_MM using decoder 70
                                             //  820:   }
                                             //  820:   } // switch Inst[10:6]
                                             //  820:  }
  44, 6,                                     //  824:  case 0x2c: {
  OPC_CheckPredicate, 1,                     //  826:   check predicate 1
  OPC_Decode, 206, 12, 72,                   //  828:   decode to EXT_MM using decoder 72
                                             //  828:  }
  45, 83,                                    //  832:  case 0x2d: {
  OPC_SwitchField, 6, 5,                     //  834:   switch Inst[10:6] {
  0, 6,                                      //  837:   case 0x0: {
  OPC_CheckPredicate, 10,                    //  839:    check predicate 10
  OPC_Decode, 253, 17, 64,                   //  841:    decode to MUL_PH_MMR2 using decoder 64
                                             //  841:   }
  1, 6,                                      //  845:   case 0x1: {
  OPC_CheckPredicate, 10,                    //  847:    check predicate 10
  OPC_Decode, 230, 18, 64,                   //  849:    decode to PRECR_QB_PH_MMR2 using decoder 64
                                             //  849:   }
  2, 6,                                      //  853:   case 0x2: {
  OPC_CheckPredicate, 9,                     //  855:    check predicate 9
  OPC_Decode, 226, 18, 64,                   //  857:    decode to PRECRQ_QB_PH_MM using decoder 64
                                             //  857:   }
  3, 6,                                      //  861:   case 0x3: {
  OPC_CheckPredicate, 9,                     //  863:    check predicate 9
  OPC_Decode, 224, 18, 73,                   //  865:    decode to PRECRQ_PH_W_MM using decoder 73
                                             //  865:   }
  4, 6,                                      //  869:   case 0x4: {
  OPC_CheckPredicate, 9,                     //  871:    check predicate 9
  OPC_Decode, 228, 18, 73,                   //  873:    decode to PRECRQ_RS_PH_W_MM using decoder 73
                                             //  873:   }
  5, 6,                                      //  877:   case 0x5: {
  OPC_CheckPredicate, 9,                     //  879:    check predicate 9
  OPC_Decode, 222, 18, 64,                   //  881:    decode to PRECRQU_S_QB_PH_MM using decoder 64
                                             //  881:   }
  6, 6,                                      //  885:   case 0x6: {
  OPC_CheckPredicate, 9,                     //  887:    check predicate 9
  OPC_Decode, 178, 18, 64,                   //  889:    decode to PACKRL_PH_MM using decoder 64
                                             //  889:   }
  7, 6,                                      //  893:   case 0x7: {
  OPC_CheckPredicate, 9,                     //  895:    check predicate 9
  OPC_Decode, 197, 18, 64,                   //  897:    decode to PICK_QB_MM using decoder 64
                                             //  897:   }
  8, 6,                                      //  901:   case 0x8: {
  OPC_CheckPredicate, 9,                     //  903:    check predicate 9
  OPC_Decode, 195, 18, 64,                   //  905:    decode to PICK_PH_MM using decoder 64
                                             //  905:   }
  16, 0,                                     //  909:   case 0x10: {
  OPC_CheckPredicate, 10,                    //  911:    check predicate 10
  OPC_Decode, 130, 18, 64,                   //  913:    decode to MUL_S_PH_MMR2 using decoder 64
                                             //  913:   }
                                             //  913:   } // switch Inst[10:6]
                                             //  913:  }
  52, 27,                                    //  917:  case 0x34: {
  OPC_SwitchField, 6, 5,                     //  919:   switch Inst[10:6] {
  19, 10,                                    //  922:   case 0x13: {
  OPC_CheckPredicate, 11,                    //  924:    check predicate 11
  OPC_CheckField, 14, 2, 0,                  //  926:    check Inst[15:14] == 0x0
  OPC_Decode, 172, 16, 74,                   //  930:    decode to MFHGC0_MM using decoder 74
                                             //  930:   }
  27, 0,                                     //  934:   case 0x1b: {
  OPC_CheckPredicate, 11,                    //  936:    check predicate 11
  OPC_CheckField, 14, 2, 0,                  //  938:    check Inst[15:14] == 0x0
  OPC_Decode, 188, 17, 75,                   //  942:    decode to MTHGC0_MM using decoder 75
                                             //  942:   }
                                             //  942:   } // switch Inst[10:6]
                                             //  942:  }
  53, 64,                                    //  946:  case 0x35: {
  OPC_SwitchField, 6, 5,                     //  948:   switch Inst[10:6] {
  11, 6,                                     //  951:   case 0xb: {
  OPC_CheckPredicate, 9,                     //  953:    check predicate 9
  OPC_Decode, 164, 20, 58,                   //  955:    decode to SHRA_R_W_MM using decoder 58
                                             //  955:   }
  12, 10,                                    //  959:   case 0xc: {
  OPC_CheckPredicate, 9,                     //  961:    check predicate 9
  OPC_CheckField, 11, 1, 0,                  //  963:    check Inst[11] == 0x0
  OPC_Decode, 156, 20, 76,                   //  967:    decode to SHRA_PH_MM using decoder 76
                                             //  967:   }
  14, 19,                                    //  971:   case 0xe: {
  OPC_SwitchField, 11, 1,                    //  973:    switch Inst[11] {
  0, 6,                                      //  976:    case 0x0: {
  OPC_CheckPredicate, 9,                     //  978:     check predicate 9
  OPC_Decode, 138, 20, 76,                   //  980:     decode to SHLL_PH_MM using decoder 76
                                             //  980:    }
  1, 0,                                      //  984:    case 0x1: {
  OPC_CheckPredicate, 9,                     //  986:     check predicate 9
  OPC_Decode, 142, 20, 76,                   //  988:     decode to SHLL_S_PH_MM using decoder 76
                                             //  988:    }
                                             //  988:    } // switch Inst[11]
                                             //  988:   }
  15, 6,                                     //  992:   case 0xf: {
  OPC_CheckPredicate, 9,                     //  994:    check predicate 9
  OPC_Decode, 144, 20, 58,                   //  996:    decode to SHLL_S_W_MM using decoder 58
                                             //  996:   }
  28, 0,                                     // 1000:   case 0x1c: {
  OPC_CheckPredicate, 9,                     // 1002:    check predicate 9
  OPC_CheckField, 11, 1, 0,                  // 1004:    check Inst[11] == 0x0
  OPC_Decode, 160, 20, 76,                   // 1008:    decode to SHRA_R_PH_MM using decoder 76
                                             // 1008:   }
                                             // 1008:   } // switch Inst[10:6]
                                             // 1008:  }
  60, 165, 9,                                // 1012:  case 0x3c: {
  OPC_SwitchField, 6, 5,                     // 1015:   switch Inst[10:6] {
  0, 19,                                     // 1018:   case 0x0: {
  OPC_SwitchField, 11, 1,                    // 1020:    switch Inst[11] {
  0, 6,                                      // 1023:    case 0x0: {
  OPC_CheckPredicate, 2,                     // 1025:     check predicate 2
  OPC_Decode, 144, 22, 77,                   // 1027:     decode to TEQ_MM using decoder 77
                                             // 1027:    }
  1, 0,                                      // 1031:    case 0x1: {
  OPC_CheckPredicate, 2,                     // 1033:     check predicate 2
  OPC_Decode, 183, 22, 77,                   // 1035:     decode to TLT_MM using decoder 77
                                             // 1035:    }
                                             // 1035:    } // switch Inst[11]
                                             // 1035:   }
  1, 77,                                     // 1039:   case 0x1: {
  OPC_SwitchField, 11, 2,                    // 1041:    switch Inst[12:11] {
  0, 27,                                     // 1044:    case 0x0: {
  OPC_SwitchField, 13, 1,                    // 1046:     switch Inst[13] {
  0, 10,                                     // 1049:     case 0x0: {
  OPC_CheckPredicate, 9,                     // 1051:      check predicate 9
  OPC_CheckField, 21, 5, 0,                  // 1053:      check Inst[25:21] == 0x0
  OPC_Decode, 177, 16, 78,                   // 1057:      decode to MFHI_DSP_MM using decoder 78
                                             // 1057:     }
  1, 0,                                      // 1061:     case 0x1: {
  OPC_CheckPredicate, 9,                     // 1063:      check predicate 9
  OPC_CheckField, 21, 5, 0,                  // 1065:      check Inst[25:21] == 0x0
  OPC_Decode, 192, 17, 79,                   // 1069:      decode to MTHI_DSP_MM using decoder 79
                                             // 1069:     }
                                             // 1069:     } // switch Inst[13]
                                             // 1069:    }
  1, 6,                                      // 1073:    case 0x1: {
  OPC_CheckPredicate, 9,                     // 1075:     check predicate 9
  OPC_Decode, 140, 20, 80,                   // 1077:     decode to SHLL_QB_MM using decoder 80
                                             // 1077:    }
  2, 27,                                     // 1081:    case 0x2: {
  OPC_SwitchField, 13, 1,                    // 1083:     switch Inst[13] {
  0, 10,                                     // 1086:     case 0x0: {
  OPC_CheckPredicate, 9,                     // 1088:      check predicate 9
  OPC_CheckField, 21, 5, 0,                  // 1090:      check Inst[25:21] == 0x0
  OPC_Decode, 183, 16, 78,                   // 1094:      decode to MFLO_DSP_MM using decoder 78
                                             // 1094:     }
  1, 0,                                      // 1098:     case 0x1: {
  OPC_CheckPredicate, 9,                     // 1100:      check predicate 9
  OPC_CheckField, 21, 5, 0,                  // 1102:      check Inst[25:21] == 0x0
  OPC_Decode, 199, 17, 81,                   // 1106:      decode to MTLO_DSP_MM using decoder 81
                                             // 1106:     }
                                             // 1106:     } // switch Inst[13]
                                             // 1106:    }
  3, 0,                                      // 1110:    case 0x3: {
  OPC_CheckPredicate, 9,                     // 1112:     check predicate 9
  OPC_Decode, 172, 20, 80,                   // 1114:     decode to SHRL_QB_MM using decoder 80
                                             // 1114:    }
                                             // 1114:    } // switch Inst[12:11]
                                             // 1114:   }
  2, 59,                                     // 1118:   case 0x2: {
  OPC_SwitchField, 11, 3,                    // 1120:    switch Inst[13:11] {
  0, 6,                                      // 1123:    case 0x0: {
  OPC_CheckPredicate, 10,                    // 1125:     check predicate 10
  OPC_Decode, 244, 11, 82,                   // 1127:     decode to DPA_W_PH_MMR2 using decoder 82
                                             // 1127:    }
  1, 6,                                      // 1131:    case 0x1: {
  OPC_CheckPredicate, 10,                    // 1133:     check predicate 10
  OPC_Decode, 156, 7, 83,                    // 1135:     decode to BALIGN_MMR2 using decoder 83
                                             // 1135:    }
  2, 6,                                      // 1139:    case 0x2: {
  OPC_CheckPredicate, 10,                    // 1141:     check predicate 10
  OPC_Decode, 242, 11, 82,                   // 1143:     decode to DPAX_W_PH_MMR2 using decoder 82
                                             // 1143:    }
  4, 6,                                      // 1147:    case 0x4: {
  OPC_CheckPredicate, 9,                     // 1149:     check predicate 9
  OPC_Decode, 238, 11, 82,                   // 1151:     decode to DPAU_H_QBL_MM using decoder 82
                                             // 1151:    }
  5, 6,                                      // 1155:    case 0x5: {
  OPC_CheckPredicate, 9,                     // 1157:     check predicate 9
  OPC_Decode, 186, 12, 84,                   // 1159:     decode to EXTPV_MM using decoder 84
                                             // 1159:    }
  6, 6,                                      // 1163:    case 0x6: {
  OPC_CheckPredicate, 9,                     // 1165:     check predicate 9
  OPC_Decode, 240, 11, 82,                   // 1167:     decode to DPAU_H_QBR_MM using decoder 82
                                             // 1167:    }
  7, 0,                                      // 1171:    case 0x7: {
  OPC_CheckPredicate, 9,                     // 1173:     check predicate 9
  OPC_Decode, 183, 12, 84,                   // 1175:     decode to EXTPDPV_MM using decoder 84
                                             // 1175:    }
                                             // 1175:    } // switch Inst[13:11]
                                             // 1175:   }
  4, 99,                                     // 1179:   case 0x4: {
  OPC_SwitchField, 11, 5,                    // 1181:    switch Inst[15:11] {
  0, 6,                                      // 1184:    case 0x0: {
  OPC_CheckPredicate, 10,                    // 1186:     check predicate 10
  OPC_Decode, 143, 6, 85,                    // 1188:     decode to ABSQ_S_QB_MMR2 using decoder 85
                                             // 1188:    }
  2, 6,                                      // 1192:    case 0x2: {
  OPC_CheckPredicate, 9,                     // 1194:     check predicate 9
  OPC_Decode, 141, 6, 85,                    // 1196:     decode to ABSQ_S_PH_MM using decoder 85
                                             // 1196:    }
  4, 6,                                      // 1200:    case 0x4: {
  OPC_CheckPredicate, 9,                     // 1202:     check predicate 9
  OPC_Decode, 145, 6, 86,                    // 1204:     decode to ABSQ_S_W_MM using decoder 86
                                             // 1204:    }
  6, 6,                                      // 1208:    case 0x6: {
  OPC_CheckPredicate, 9,                     // 1210:     check predicate 9
  OPC_Decode, 246, 7, 86,                    // 1212:     decode to BITREV_MM using decoder 86
                                             // 1212:    }
  8, 6,                                      // 1216:    case 0x8: {
  OPC_CheckPredicate, 9,                     // 1218:     check predicate 9
  OPC_Decode, 177, 14, 87,                   // 1220:     decode to INSV_MM using decoder 87
                                             // 1220:    }
  10, 6,                                     // 1224:    case 0xa: {
  OPC_CheckPredicate, 9,                     // 1226:     check predicate 9
  OPC_Decode, 210, 18, 88,                   // 1228:     decode to PRECEQ_W_PHL_MM using decoder 88
                                             // 1228:    }
  12, 6,                                     // 1232:    case 0xc: {
  OPC_CheckPredicate, 9,                     // 1234:     check predicate 9
  OPC_Decode, 212, 18, 88,                   // 1236:     decode to PRECEQ_W_PHR_MM using decoder 88
                                             // 1236:    }
  14, 6,                                     // 1240:    case 0xe: {
  OPC_CheckPredicate, 9,                     // 1242:     check predicate 9
  OPC_Decode, 204, 18, 85,                   // 1244:     decode to PRECEQU_PH_QBL_MM using decoder 85
                                             // 1244:    }
  18, 6,                                     // 1248:    case 0x12: {
  OPC_CheckPredicate, 9,                     // 1250:     check predicate 9
  OPC_Decode, 208, 18, 85,                   // 1252:     decode to PRECEQU_PH_QBR_MM using decoder 85
                                             // 1252:    }
  22, 6,                                     // 1256:    case 0x16: {
  OPC_CheckPredicate, 9,                     // 1258:     check predicate 9
  OPC_Decode, 216, 18, 85,                   // 1260:     decode to PRECEU_PH_QBL_MM using decoder 85
                                             // 1260:    }
  26, 6,                                     // 1264:    case 0x1a: {
  OPC_CheckPredicate, 9,                     // 1266:     check predicate 9
  OPC_Decode, 220, 18, 85,                   // 1268:     decode to PRECEU_PH_QBR_MM using decoder 85
                                             // 1268:    }
  30, 0,                                     // 1272:    case 0x1e: {
  OPC_CheckPredicate, 9,                     // 1274:     check predicate 9
  OPC_Decode, 247, 18, 88,                   // 1276:     decode to RADDU_W_QB_MM using decoder 88
                                             // 1276:    }
                                             // 1276:    } // switch Inst[15:11]
                                             // 1276:   }
  5, 51,                                     // 1280:   case 0x5: {
  OPC_SwitchField, 11, 15,                   // 1282:    switch Inst[25:11] {
  0, 6,                                      // 1285:    case 0x0: {
  OPC_CheckPredicate, 11,                    // 1287:     check predicate 11
  OPC_Decode, 158, 22, 10,                   // 1289:     decode to TLBGP_MM using decoder 10
                                             // 1289:    }
  2, 6,                                      // 1293:    case 0x2: {
  OPC_CheckPredicate, 11,                    // 1295:     check predicate 11
  OPC_Decode, 160, 22, 10,                   // 1297:     decode to TLBGR_MM using decoder 10
                                             // 1297:    }
  4, 6,                                      // 1301:    case 0x4: {
  OPC_CheckPredicate, 11,                    // 1303:     check predicate 11
  OPC_Decode, 162, 22, 10,                   // 1305:     decode to TLBGWI_MM using decoder 10
                                             // 1305:    }
  6, 6,                                      // 1309:    case 0x6: {
  OPC_CheckPredicate, 11,                    // 1311:     check predicate 11
  OPC_Decode, 164, 22, 10,                   // 1313:     decode to TLBGWR_MM using decoder 10
                                             // 1313:    }
  8, 6,                                      // 1317:    case 0x8: {
  OPC_CheckPredicate, 11,                    // 1319:     check predicate 11
  OPC_Decode, 156, 22, 10,                   // 1321:     decode to TLBGINV_MM using decoder 10
                                             // 1321:    }
  10, 0,                                     // 1325:    case 0xa: {
  OPC_CheckPredicate, 11,                    // 1327:     check predicate 11
  OPC_Decode, 155, 22, 10,                   // 1329:     decode to TLBGINVF_MM using decoder 10
                                             // 1329:    }
                                             // 1329:    } // switch Inst[25:11]
                                             // 1329:   }
  7, 19,                                     // 1333:   case 0x7: {
  OPC_SwitchField, 11, 2,                    // 1335:    switch Inst[12:11] {
  0, 6,                                      // 1338:    case 0x0: {
  OPC_CheckPredicate, 10,                    // 1340:     check predicate 10
  OPC_Decode, 158, 20, 80,                   // 1342:     decode to SHRA_QB_MMR2 using decoder 80
                                             // 1342:    }
  2, 0,                                      // 1346:    case 0x2: {
  OPC_CheckPredicate, 10,                    // 1348:     check predicate 10
  OPC_Decode, 162, 20, 80,                   // 1350:     decode to SHRA_R_QB_MMR2 using decoder 80
                                             // 1350:    }
                                             // 1350:    } // switch Inst[12:11]
                                             // 1350:   }
  8, 19,                                     // 1354:   case 0x8: {
  OPC_SwitchField, 11, 1,                    // 1356:    switch Inst[11] {
  0, 6,                                      // 1359:    case 0x0: {
  OPC_CheckPredicate, 2,                     // 1361:     check predicate 2
  OPC_Decode, 152, 22, 77,                   // 1363:     decode to TGE_MM using decoder 77
                                             // 1363:    }
  1, 0,                                      // 1367:    case 0x1: {
  OPC_CheckPredicate, 2,                     // 1369:     check predicate 2
  OPC_Decode, 182, 22, 77,                   // 1371:     decode to TLTU_MM using decoder 77
                                             // 1371:    }
                                             // 1371:    } // switch Inst[11]
                                             // 1371:   }
  9, 59,                                     // 1375:   case 0x9: {
  OPC_SwitchField, 11, 3,                    // 1377:    switch Inst[13:11] {
  0, 10,                                     // 1380:    case 0x0: {
  OPC_CheckPredicate, 9,                     // 1382:     check predicate 9
  OPC_CheckField, 21, 5, 0,                  // 1384:     check Inst[25:21] == 0x0
  OPC_Decode, 195, 17, 89,                   // 1388:     decode to MTHLIP_MM using decoder 89
                                             // 1388:    }
  1, 6,                                      // 1392:    case 0x1: {
  OPC_CheckPredicate, 9,                     // 1394:     check predicate 9
  OPC_Decode, 254, 15, 82,                   // 1396:     decode to MAQ_S_W_PHR_MM using decoder 82
                                             // 1396:    }
  2, 10,                                     // 1400:    case 0x2: {
  OPC_CheckPredicate, 9,                     // 1402:     check predicate 9
  OPC_CheckField, 21, 5, 0,                  // 1404:     check Inst[25:21] == 0x0
  OPC_Decode, 255, 19, 89,                   // 1408:     decode to SHILOV_MM using decoder 89
                                             // 1408:    }
  3, 6,                                      // 1412:    case 0x3: {
  OPC_CheckPredicate, 9,                     // 1414:     check predicate 9
  OPC_Decode, 252, 15, 82,                   // 1416:     decode to MAQ_S_W_PHL_MM using decoder 82
                                             // 1416:    }
  5, 6,                                      // 1420:    case 0x5: {
  OPC_CheckPredicate, 9,                     // 1422:     check predicate 9
  OPC_Decode, 250, 15, 82,                   // 1424:     decode to MAQ_SA_W_PHR_MM using decoder 82
                                             // 1424:    }
  7, 0,                                      // 1428:    case 0x7: {
  OPC_CheckPredicate, 9,                     // 1430:     check predicate 9
  OPC_Decode, 248, 15, 82,                   // 1432:     decode to MAQ_SA_W_PHL_MM using decoder 82
                                             // 1432:    }
                                             // 1432:    } // switch Inst[13:11]
                                             // 1432:   }
  10, 67,                                    // 1436:   case 0xa: {
  OPC_SwitchField, 11, 3,                    // 1438:    switch Inst[13:11] {
  0, 6,                                      // 1441:    case 0x0: {
  OPC_CheckPredicate, 9,                     // 1443:     check predicate 9
  OPC_Decode, 236, 11, 82,                   // 1445:     decode to DPAQ_S_W_PH_MM using decoder 82
                                             // 1445:    }
  1, 6,                                      // 1449:    case 0x1: {
  OPC_CheckPredicate, 9,                     // 1451:     check predicate 9
  OPC_Decode, 241, 15, 90,                   // 1453:     decode to MADD_DSP_MM using decoder 90
                                             // 1453:    }
  2, 6,                                      // 1457:    case 0x2: {
  OPC_CheckPredicate, 9,                     // 1459:     check predicate 9
  OPC_Decode, 234, 11, 82,                   // 1461:     decode to DPAQ_SA_L_W_MM using decoder 82
                                             // 1461:    }
  3, 6,                                      // 1465:    case 0x3: {
  OPC_CheckPredicate, 9,                     // 1467:     check predicate 9
  OPC_Decode, 231, 15, 90,                   // 1469:     decode to MADDU_DSP_MM using decoder 90
                                             // 1469:    }
  4, 6,                                      // 1473:    case 0x4: {
  OPC_CheckPredicate, 10,                    // 1475:     check predicate 10
  OPC_Decode, 232, 11, 82,                   // 1477:     decode to DPAQX_S_W_PH_MMR2 using decoder 82
                                             // 1477:    }
  5, 6,                                      // 1481:    case 0x5: {
  OPC_CheckPredicate, 9,                     // 1483:     check predicate 9
  OPC_Decode, 164, 17, 90,                   // 1485:     decode to MSUB_DSP_MM using decoder 90
                                             // 1485:    }
  6, 6,                                      // 1489:    case 0x6: {
  OPC_CheckPredicate, 10,                    // 1491:     check predicate 10
  OPC_Decode, 230, 11, 82,                   // 1493:     decode to DPAQX_SA_W_PH_MMR2 using decoder 82
                                             // 1493:    }
  7, 0,                                      // 1497:    case 0x7: {
  OPC_CheckPredicate, 9,                     // 1499:     check predicate 9
  OPC_Decode, 154, 17, 90,                   // 1501:     decode to MSUBU_DSP_MM using decoder 90
                                             // 1501:    }
                                             // 1501:    } // switch Inst[13:11]
                                             // 1501:   }
  12, 163, 1,                                // 1505:   case 0xc: {
  OPC_SwitchField, 11, 5,                    // 1508:    switch Inst[15:11] {
  0, 6,                                      // 1511:    case 0x0: {
  OPC_CheckPredicate, 9,                     // 1513:     check predicate 9
  OPC_Decode, 134, 19, 91,                   // 1515:     decode to REPLV_PH_MM using decoder 91
                                             // 1515:    }
  2, 6,                                      // 1519:    case 0x2: {
  OPC_CheckPredicate, 9,                     // 1521:     check predicate 9
  OPC_Decode, 136, 19, 91,                   // 1523:     decode to REPLV_QB_MM using decoder 91
                                             // 1523:    }
  5, 6,                                      // 1527:    case 0x5: {
  OPC_CheckPredicate, 2,                     // 1529:     check predicate 2
  OPC_Decode, 220, 19, 86,                   // 1531:     decode to SEB_MM using decoder 86
                                             // 1531:    }
  7, 6,                                      // 1535:    case 0x7: {
  OPC_CheckPredicate, 2,                     // 1537:     check predicate 2
  OPC_Decode, 223, 19, 86,                   // 1539:     decode to SEH_MM using decoder 86
                                             // 1539:    }
  9, 6,                                      // 1543:    case 0x9: {
  OPC_CheckPredicate, 2,                     // 1545:     check predicate 2
  OPC_Decode, 145, 9, 86,                    // 1547:     decode to CLO_MM using decoder 86
                                             // 1547:    }
  11, 6,                                     // 1551:    case 0xb: {
  OPC_CheckPredicate, 2,                     // 1553:     check predicate 2
  OPC_Decode, 165, 9, 86,                    // 1555:     decode to CLZ_MM using decoder 86
                                             // 1555:    }
  13, 6,                                     // 1559:    case 0xd: {
  OPC_CheckPredicate, 1,                     // 1561:     check predicate 1
  OPC_Decode, 252, 18, 92,                   // 1563:     decode to RDHWR_MM using decoder 92
                                             // 1563:    }
  14, 6,                                     // 1567:    case 0xe: {
  OPC_CheckPredicate, 9,                     // 1569:     check predicate 9
  OPC_Decode, 203, 18, 85,                   // 1571:     decode to PRECEQU_PH_QBLA_MM using decoder 85
                                             // 1571:    }
  15, 6,                                     // 1575:    case 0xf: {
  OPC_CheckPredicate, 2,                     // 1577:     check predicate 2
  OPC_Decode, 216, 22, 86,                   // 1579:     decode to WSBH_MM using decoder 86
                                             // 1579:    }
  17, 6,                                     // 1583:    case 0x11: {
  OPC_CheckPredicate, 1,                     // 1585:     check predicate 1
  OPC_Decode, 241, 17, 93,                   // 1587:     decode to MULT_MM using decoder 93
                                             // 1587:    }
  18, 6,                                     // 1591:    case 0x12: {
  OPC_CheckPredicate, 9,                     // 1593:     check predicate 9
  OPC_Decode, 207, 18, 85,                   // 1595:     decode to PRECEQU_PH_QBRA_MM using decoder 85
                                             // 1595:    }
  19, 6,                                     // 1599:    case 0x13: {
  OPC_CheckPredicate, 1,                     // 1601:     check predicate 1
  OPC_Decode, 243, 17, 93,                   // 1603:     decode to MULTu_MM using decoder 93
                                             // 1603:    }
  21, 6,                                     // 1607:    case 0x15: {
  OPC_CheckPredicate, 1,                     // 1609:     check predicate 1
  OPC_Decode, 213, 19, 93,                   // 1611:     decode to SDIV_MM using decoder 93
                                             // 1611:    }
  22, 6,                                     // 1615:    case 0x16: {
  OPC_CheckPredicate, 9,                     // 1617:     check predicate 9
  OPC_Decode, 215, 18, 85,                   // 1619:     decode to PRECEU_PH_QBLA_MM using decoder 85
                                             // 1619:    }
  23, 6,                                     // 1623:    case 0x17: {
  OPC_CheckPredicate, 1,                     // 1625:     check predicate 1
  OPC_Decode, 201, 22, 93,                   // 1627:     decode to UDIV_MM using decoder 93
                                             // 1627:    }
  25, 6,                                     // 1631:    case 0x19: {
  OPC_CheckPredicate, 1,                     // 1633:     check predicate 1
  OPC_Decode, 242, 15, 93,                   // 1635:     decode to MADD_MM using decoder 93
                                             // 1635:    }
  26, 6,                                     // 1639:    case 0x1a: {
  OPC_CheckPredicate, 9,                     // 1641:     check predicate 9
  OPC_Decode, 219, 18, 85,                   // 1643:     decode to PRECEU_PH_QBRA_MM using decoder 85
                                             // 1643:    }
  27, 6,                                     // 1647:    case 0x1b: {
  OPC_CheckPredicate, 1,                     // 1649:     check predicate 1
  OPC_Decode, 232, 15, 93,                   // 1651:     decode to MADDU_MM using decoder 93
                                             // 1651:    }
  29, 6,                                     // 1655:    case 0x1d: {
  OPC_CheckPredicate, 1,                     // 1657:     check predicate 1
  OPC_Decode, 165, 17, 93,                   // 1659:     decode to MSUB_MM using decoder 93
                                             // 1659:    }
  31, 0,                                     // 1663:    case 0x1f: {
  OPC_CheckPredicate, 1,                     // 1665:     check predicate 1
  OPC_Decode, 155, 17, 93,                   // 1667:     decode to MSUBU_MM using decoder 93
                                             // 1667:    }
                                             // 1667:    } // switch Inst[15:11]
                                             // 1667:   }
  13, 119,                                   // 1671:   case 0xd: {
  OPC_SwitchField, 11, 5,                    // 1673:    switch Inst[15:11] {
  0, 10,                                     // 1676:    case 0x0: {
  OPC_CheckPredicate, 2,                     // 1678:     check predicate 2
  OPC_CheckField, 16, 10, 0,                 // 1680:     check Inst[25:16] == 0x0
  OPC_Decode, 170, 22, 10,                   // 1684:     decode to TLBP_MM using decoder 10
                                             // 1684:    }
  2, 10,                                     // 1688:    case 0x2: {
  OPC_CheckPredicate, 2,                     // 1690:     check predicate 2
  OPC_CheckField, 16, 10, 0,                 // 1692:     check Inst[25:16] == 0x0
  OPC_Decode, 172, 22, 10,                   // 1696:     decode to TLBR_MM using decoder 10
                                             // 1696:    }
  4, 10,                                     // 1700:    case 0x4: {
  OPC_CheckPredicate, 2,                     // 1702:     check predicate 2
  OPC_CheckField, 16, 10, 0,                 // 1704:     check Inst[25:16] == 0x0
  OPC_Decode, 174, 22, 10,                   // 1708:     decode to TLBWI_MM using decoder 10
                                             // 1708:    }
  6, 10,                                     // 1712:    case 0x6: {
  OPC_CheckPredicate, 2,                     // 1714:     check predicate 2
  OPC_CheckField, 16, 10, 0,                 // 1716:     check Inst[25:16] == 0x0
  OPC_Decode, 176, 22, 10,                   // 1720:     decode to TLBWR_MM using decoder 10
                                             // 1720:    }
  13, 10,                                    // 1724:    case 0xd: {
  OPC_CheckPredicate, 2,                     // 1726:     check predicate 2
  OPC_CheckField, 21, 5, 0,                  // 1728:     check Inst[25:21] == 0x0
  OPC_Decode, 244, 21, 94,                   // 1732:     decode to SYNC_MM using decoder 94
                                             // 1732:    }
  17, 6,                                     // 1736:    case 0x11: {
  OPC_CheckPredicate, 2,                     // 1738:     check predicate 2
  OPC_Decode, 247, 21, 95,                   // 1740:     decode to SYSCALL_MM using decoder 95
                                             // 1740:    }
  18, 6,                                     // 1744:    case 0x12: {
  OPC_CheckPredicate, 2,                     // 1746:     check predicate 2
  OPC_Decode, 210, 22, 95,                   // 1748:     decode to WAIT_MM using decoder 95
                                             // 1748:    }
  24, 6,                                     // 1752:    case 0x18: {
  OPC_CheckPredicate, 11,                    // 1754:     check predicate 11
  OPC_Decode, 150, 14, 95,                   // 1756:     decode to HYPCALL_MM using decoder 95
                                             // 1756:    }
  27, 6,                                     // 1760:    case 0x1b: {
  OPC_CheckPredicate, 2,                     // 1762:     check predicate 2
  OPC_Decode, 200, 19, 95,                   // 1764:     decode to SDBBP_MM using decoder 95
                                             // 1764:    }
  28, 10,                                    // 1768:    case 0x1c: {
  OPC_CheckPredicate, 2,                     // 1770:     check predicate 2
  OPC_CheckField, 16, 10, 0,                 // 1772:     check Inst[25:16] == 0x0
  OPC_Decode, 171, 11, 10,                   // 1776:     decode to DERET_MM using decoder 10
                                             // 1776:    }
  30, 0,                                     // 1780:    case 0x1e: {
  OPC_CheckPredicate, 2,                     // 1782:     check predicate 2
  OPC_CheckField, 16, 10, 0,                 // 1784:     check Inst[25:16] == 0x0
  OPC_Decode, 174, 12, 10,                   // 1788:     decode to ERET_MM using decoder 10
                                             // 1788:    }
                                             // 1788:    } // switch Inst[15:11]
                                             // 1788:   }
  15, 10,                                    // 1792:   case 0xf: {
  OPC_CheckPredicate, 10,                    // 1794:    check predicate 10
  OPC_CheckField, 11, 1, 0,                  // 1796:    check Inst[11] == 0x0
  OPC_Decode, 170, 20, 76,                   // 1800:    decode to SHRL_PH_MMR2 using decoder 76
                                             // 1800:   }
  16, 19,                                    // 1804:   case 0x10: {
  OPC_SwitchField, 11, 1,                    // 1806:    switch Inst[11] {
  0, 6,                                      // 1809:    case 0x0: {
  OPC_CheckPredicate, 2,                     // 1811:     check predicate 2
  OPC_Decode, 151, 22, 77,                   // 1813:     decode to TGEU_MM using decoder 77
                                             // 1813:    }
  1, 0,                                      // 1817:    case 0x1: {
  OPC_CheckPredicate, 2,                     // 1819:     check predicate 2
  OPC_Decode, 187, 22, 77,                   // 1821:     decode to TNE_MM using decoder 77
                                             // 1821:    }
                                             // 1821:    } // switch Inst[11]
                                             // 1821:   }
  18, 67,                                    // 1825:   case 0x12: {
  OPC_SwitchField, 11, 3,                    // 1827:    switch Inst[13:11] {
  0, 6,                                      // 1830:    case 0x0: {
  OPC_CheckPredicate, 10,                    // 1832:     check predicate 10
  OPC_Decode, 139, 12, 82,                   // 1834:     decode to DPS_W_PH_MMR2 using decoder 82
                                             // 1834:    }
  1, 6,                                      // 1838:    case 0x1: {
  OPC_CheckPredicate, 9,                     // 1840:     check predicate 9
  OPC_Decode, 240, 17, 96,                   // 1842:     decode to MULT_DSP_MM using decoder 96
                                             // 1842:    }
  2, 6,                                      // 1846:    case 0x2: {
  OPC_CheckPredicate, 10,                    // 1848:     check predicate 10
  OPC_Decode, 137, 12, 82,                   // 1850:     decode to DPSX_W_PH_MMR2 using decoder 82
                                             // 1850:    }
  3, 6,                                      // 1854:    case 0x3: {
  OPC_CheckPredicate, 9,                     // 1856:     check predicate 9
  OPC_Decode, 238, 17, 96,                   // 1858:     decode to MULTU_DSP_MM using decoder 96
                                             // 1858:    }
  4, 6,                                      // 1862:    case 0x4: {
  OPC_CheckPredicate, 9,                     // 1864:     check predicate 9
  OPC_Decode, 133, 12, 82,                   // 1866:     decode to DPSU_H_QBL_MM using decoder 82
                                             // 1866:    }
  5, 6,                                      // 1870:    case 0x5: {
  OPC_CheckPredicate, 10,                    // 1872:     check predicate 10
  OPC_Decode, 235, 17, 82,                   // 1874:     decode to MULSA_W_PH_MMR2 using decoder 82
                                             // 1874:    }
  6, 6,                                      // 1878:    case 0x6: {
  OPC_CheckPredicate, 9,                     // 1880:     check predicate 9
  OPC_Decode, 135, 12, 82,                   // 1882:     decode to DPSU_H_QBR_MM using decoder 82
                                             // 1882:    }
  7, 0,                                      // 1886:    case 0x7: {
  OPC_CheckPredicate, 9,                     // 1888:     check predicate 9
  OPC_Decode, 233, 17, 82,                   // 1890:     decode to MULSAQ_S_W_PH_MM using decoder 82
                                             // 1890:    }
                                             // 1890:    } // switch Inst[13:11]
                                             // 1890:   }
  19, 10,                                    // 1894:   case 0x13: {
  OPC_CheckPredicate, 11,                    // 1896:    check predicate 11
  OPC_CheckField, 14, 2, 0,                  // 1898:    check Inst[15:14] == 0x0
  OPC_Decode, 164, 16, 74,                   // 1902:    decode to MFGC0_MM using decoder 74
                                             // 1902:   }
  20, 19,                                    // 1906:   case 0x14: {
  OPC_SwitchField, 11, 5,                    // 1908:    switch Inst[15:11] {
  25, 6,                                     // 1911:    case 0x19: {
  OPC_CheckPredicate, 2,                     // 1913:     check predicate 2
  OPC_Decode, 246, 8, 97,                    // 1915:     decode to CFC2_MM using decoder 97
                                             // 1915:    }
  27, 0,                                     // 1919:    case 0x1b: {
  OPC_CheckPredicate, 2,                     // 1921:     check predicate 2
  OPC_Decode, 145, 10, 98,                   // 1923:     decode to CTC2_MM using decoder 98
                                             // 1923:    }
                                             // 1923:    } // switch Inst[15:11]
                                             // 1923:   }
  21, 51,                                    // 1927:   case 0x15: {
  OPC_SwitchField, 11, 5,                    // 1929:    switch Inst[15:11] {
  1, 10,                                     // 1932:    case 0x1: {
  OPC_CheckPredicate, 1,                     // 1934:     check predicate 1
  OPC_CheckField, 21, 5, 0,                  // 1936:     check Inst[25:21] == 0x0
  OPC_Decode, 178, 16, 99,                   // 1940:     decode to MFHI_MM using decoder 99
                                             // 1940:    }
  3, 10,                                     // 1944:    case 0x3: {
  OPC_CheckPredicate, 1,                     // 1946:     check predicate 1
  OPC_CheckField, 21, 5, 0,                  // 1948:     check Inst[25:21] == 0x0
  OPC_Decode, 184, 16, 99,                   // 1952:     decode to MFLO_MM using decoder 99
                                             // 1952:    }
  5, 10,                                     // 1956:    case 0x5: {
  OPC_CheckPredicate, 1,                     // 1958:     check predicate 1
  OPC_CheckField, 21, 5, 0,                  // 1960:     check Inst[25:21] == 0x0
  OPC_Decode, 193, 17, 99,                   // 1964:     decode to MTHI_MM using decoder 99
                                             // 1964:    }
  7, 0,                                      // 1968:    case 0x7: {
  OPC_CheckPredicate, 1,                     // 1970:     check predicate 1
  OPC_CheckField, 21, 5, 0,                  // 1972:     check Inst[25:21] == 0x0
  OPC_Decode, 200, 17, 99,                   // 1976:     decode to MTLO_MM using decoder 99
                                             // 1976:    }
                                             // 1976:    } // switch Inst[15:11]
                                             // 1976:   }
  23, 10,                                    // 1980:   case 0x17: {
  OPC_CheckPredicate, 9,                     // 1982:    check predicate 9
  OPC_CheckField, 11, 2, 0,                  // 1984:    check Inst[12:11] == 0x0
  OPC_Decode, 140, 19, 100,                  // 1988:    decode to REPL_QB_MM using decoder 100
                                             // 1988:   }
  25, 67,                                    // 1992:   case 0x19: {
  OPC_SwitchField, 11, 3,                    // 1994:    switch Inst[13:11] {
  0, 6,                                      // 1997:    case 0x0: {
  OPC_CheckPredicate, 9,                     // 1999:     check predicate 9
  OPC_Decode, 249, 18, 101,                  // 2001:     decode to RDDSP_MM using decoder 101
                                             // 2001:    }
  1, 6,                                      // 2005:    case 0x1: {
  OPC_CheckPredicate, 9,                     // 2007:     check predicate 9
  OPC_Decode, 203, 12, 102,                  // 2009:     decode to EXTR_W_MM using decoder 102
                                             // 2009:    }
  2, 6,                                      // 2013:    case 0x2: {
  OPC_CheckPredicate, 9,                     // 2015:     check predicate 9
  OPC_Decode, 213, 22, 101,                  // 2017:     decode to WRDSP_MM using decoder 101
                                             // 2017:    }
  3, 6,                                      // 2021:    case 0x3: {
  OPC_CheckPredicate, 9,                     // 2023:     check predicate 9
  OPC_Decode, 199, 12, 102,                  // 2025:     decode to EXTR_R_W_MM using decoder 102
                                             // 2025:    }
  4, 6,                                      // 2029:    case 0x4: {
  OPC_CheckPredicate, 9,                     // 2031:     check predicate 9
  OPC_Decode, 187, 12, 102,                  // 2033:     decode to EXTP_MM using decoder 102
                                             // 2033:    }
  5, 6,                                      // 2037:    case 0x5: {
  OPC_CheckPredicate, 9,                     // 2039:     check predicate 9
  OPC_Decode, 197, 12, 102,                  // 2041:     decode to EXTR_RS_W_MM using decoder 102
                                             // 2041:    }
  6, 6,                                      // 2045:    case 0x6: {
  OPC_CheckPredicate, 9,                     // 2047:     check predicate 9
  OPC_Decode, 184, 12, 102,                  // 2049:     decode to EXTPDP_MM using decoder 102
                                             // 2049:    }
  7, 0,                                      // 2053:    case 0x7: {
  OPC_CheckPredicate, 9,                     // 2055:     check predicate 9
  OPC_Decode, 201, 12, 102,                  // 2057:     decode to EXTR_S_H_MM using decoder 102
                                             // 2057:    }
                                             // 2057:    } // switch Inst[13:11]
                                             // 2057:   }
  26, 67,                                    // 2061:   case 0x1a: {
  OPC_SwitchField, 11, 3,                    // 2063:    switch Inst[13:11] {
  0, 6,                                      // 2066:    case 0x0: {
  OPC_CheckPredicate, 9,                     // 2068:     check predicate 9
  OPC_Decode, 253, 11, 82,                   // 2070:     decode to DPSQ_S_W_PH_MM using decoder 82
                                             // 2070:    }
  1, 6,                                      // 2074:    case 0x1: {
  OPC_CheckPredicate, 9,                     // 2076:     check predicate 9
  OPC_Decode, 195, 12, 84,                   // 2078:     decode to EXTRV_W_MM using decoder 84
                                             // 2078:    }
  2, 6,                                      // 2082:    case 0x2: {
  OPC_CheckPredicate, 9,                     // 2084:     check predicate 9
  OPC_Decode, 251, 11, 82,                   // 2086:     decode to DPSQ_SA_L_W_MM using decoder 82
                                             // 2086:    }
  3, 6,                                      // 2090:    case 0x3: {
  OPC_CheckPredicate, 9,                     // 2092:     check predicate 9
  OPC_Decode, 191, 12, 84,                   // 2094:     decode to EXTRV_R_W_MM using decoder 84
                                             // 2094:    }
  4, 6,                                      // 2098:    case 0x4: {
  OPC_CheckPredicate, 10,                    // 2100:     check predicate 10
  OPC_Decode, 249, 11, 82,                   // 2102:     decode to DPSQX_S_W_PH_MMR2 using decoder 82
                                             // 2102:    }
  5, 6,                                      // 2106:    case 0x5: {
  OPC_CheckPredicate, 9,                     // 2108:     check predicate 9
  OPC_Decode, 189, 12, 84,                   // 2110:     decode to EXTRV_RS_W_MM using decoder 84
                                             // 2110:    }
  6, 6,                                      // 2114:    case 0x6: {
  OPC_CheckPredicate, 10,                    // 2116:     check predicate 10
  OPC_Decode, 247, 11, 82,                   // 2118:     decode to DPSQX_SA_W_PH_MMR2 using decoder 82
                                             // 2118:    }
  7, 0,                                      // 2122:    case 0x7: {
  OPC_CheckPredicate, 9,                     // 2124:     check predicate 9
  OPC_Decode, 193, 12, 84,                   // 2126:     decode to EXTRV_S_H_MM using decoder 84
                                             // 2126:    }
                                             // 2126:    } // switch Inst[13:11]
                                             // 2126:   }
  27, 10,                                    // 2130:   case 0x1b: {
  OPC_CheckPredicate, 11,                    // 2132:    check predicate 11
  OPC_CheckField, 14, 2, 0,                  // 2134:    check Inst[15:14] == 0x0
  OPC_Decode, 180, 17, 75,                   // 2138:    decode to MTGC0_MM using decoder 75
                                             // 2138:   }
  28, 31,                                    // 2142:   case 0x1c: {
  OPC_SwitchField, 11, 5,                    // 2144:    switch Inst[15:11] {
  1, 18,                                     // 2147:    case 0x1: {
  OPC_Scope, 10,                             // 2149:     try {
  OPC_CheckField, 21, 5, 0,                  // 2151:      check Inst[25:21] == 0x0
  OPC_CheckPredicate, 1,                     // 2155:      check predicate 1
  OPC_Decode, 214, 14, 99,                   // 2157:      decode to JR_MM using decoder 99
                                             // 2157:     } else try {
  OPC_CheckPredicate, 1,                     // 2161:      check predicate 1
  OPC_Decode, 192, 14, 86,                   // 2163:      decode to JALR_MM using decoder 86
                                             // 2163:     }
                                             // 2163:    }
  9, 0,                                      // 2167:    case 0x9: {
  OPC_CheckPredicate, 1,                     // 2169:     check predicate 1
  OPC_Decode, 189, 14, 86,                   // 2171:     decode to JALRS_MM using decoder 86
                                             // 2171:    }
                                             // 2171:    } // switch Inst[15:11]
                                             // 2171:   }
  29, 0,                                     // 2175:   case 0x1d: {
  OPC_SwitchField, 11, 5,                    // 2177:    switch Inst[15:11] {
  8, 10,                                     // 2180:    case 0x8: {
  OPC_CheckPredicate, 2,                     // 2182:     check predicate 2
  OPC_CheckField, 21, 5, 0,                  // 2184:     check Inst[25:21] == 0x0
  OPC_Decode, 193, 11, 99,                   // 2188:     decode to DI_MM using decoder 99
                                             // 2188:    }
  10, 0,                                     // 2192:    case 0xa: {
  OPC_CheckPredicate, 2,                     // 2194:     check predicate 2
  OPC_CheckField, 21, 5, 0,                  // 2196:     check Inst[25:21] == 0x0
  OPC_Decode, 168, 12, 99,                   // 2200:     decode to EI_MM using decoder 99
                                             // 2200:    }
                                             // 2200:    } // switch Inst[15:11]
                                             // 2200:   }
                                             // 2200:   } // switch Inst[10:6]
                                             // 2200:  }
  61, 0,                                     // 2204:  case 0x3d: {
  OPC_CheckPredicate, 9,                     // 2206:   check predicate 9
  OPC_CheckField, 6, 5, 0,                   // 2208:   check Inst[10:6] == 0x0
  OPC_Decode, 138, 19, 103,                  // 2212:   decode to REPL_PH_MM using decoder 103
                                             // 2212:  }
                                             // 2212:  } // switch Inst[5:0]
                                             // 2212: }
  4, 6,                                      // 2216: case 0x4: {
  OPC_CheckPredicate, 1,                     // 2218:  check predicate 1
  OPC_Decode, 216, 6, 104,                   // 2220:  decode to ADDi_MM using decoder 104
                                             // 2220: }
  5, 6,                                      // 2224: case 0x5: {
  OPC_CheckPredicate, 2,                     // 2226:  check predicate 2
  OPC_Decode, 236, 14, 105,                  // 2228:  decode to LBu_MM using decoder 105
                                             // 2228: }
  6, 6,                                      // 2232: case 0x6: {
  OPC_CheckPredicate, 2,                     // 2234:  check predicate 2
  OPC_Decode, 184, 19, 105,                  // 2236:  decode to SB_MM using decoder 105
                                             // 2236: }
  7, 6,                                      // 2240: case 0x7: {
  OPC_CheckPredicate, 2,                     // 2242:  check predicate 2
  OPC_Decode, 230, 14, 105,                  // 2244:  decode to LB_MM using decoder 105
                                             // 2244: }
  8, 43,                                     // 2248: case 0x8: {
  OPC_SwitchField, 12, 4,                    // 2250:  switch Inst[15:12] {
  1, 6,                                      // 2253:  case 0x1: {
  OPC_CheckPredicate, 2,                     // 2255:   check predicate 2
  OPC_Decode, 194, 15, 106,                  // 2257:   decode to LWP_MM using decoder 106
                                             // 2257:  }
  5, 6,                                      // 2261:  case 0x5: {
  OPC_CheckPredicate, 2,                     // 2263:   check predicate 2
  OPC_Decode, 191, 15, 106,                  // 2265:   decode to LWM32_MM using decoder 106
                                             // 2265:  }
  6, 6,                                      // 2269:  case 0x6: {
  OPC_CheckPredicate, 1,                     // 2271:   check predicate 1
  OPC_Decode, 222, 8, 107,                   // 2273:   decode to CACHE_MM using decoder 107
                                             // 2273:  }
  9, 6,                                      // 2277:  case 0x9: {
  OPC_CheckPredicate, 2,                     // 2279:   check predicate 2
  OPC_Decode, 228, 21, 106,                  // 2281:   decode to SWP_MM using decoder 106
                                             // 2281:  }
  13, 0,                                     // 2285:  case 0xd: {
  OPC_CheckPredicate, 2,                     // 2287:   check predicate 2
  OPC_Decode, 227, 21, 106,                  // 2289:   decode to SWM32_MM using decoder 106
                                             // 2289:  }
                                             // 2289:  } // switch Inst[15:12]
                                             // 2289: }
  12, 6,                                     // 2293: case 0xc: {
  OPC_CheckPredicate, 1,                     // 2295:  check predicate 1
  OPC_Decode, 218, 6, 104,                   // 2297:  decode to ADDiu_MM using decoder 104
                                             // 2297: }
  13, 6,                                     // 2301: case 0xd: {
  OPC_CheckPredicate, 2,                     // 2303:  check predicate 2
  OPC_Decode, 147, 15, 105,                  // 2305:  decode to LHu_MM using decoder 105
                                             // 2305: }
  14, 6,                                     // 2309: case 0xe: {
  OPC_CheckPredicate, 2,                     // 2311:  check predicate 2
  OPC_Decode, 173, 20, 105,                  // 2313:  decode to SH_MM using decoder 105
                                             // 2313: }
  15, 6,                                     // 2317: case 0xf: {
  OPC_CheckPredicate, 2,                     // 2319:  check predicate 2
  OPC_Decode, 142, 15, 105,                  // 2321:  decode to LH_MM using decoder 105
                                             // 2321: }
  16, 195, 1,                                // 2325: case 0x10: {
  OPC_SwitchField, 21, 5,                    // 2328:  switch Inst[25:21] {
  0, 6,                                      // 2331:  case 0x0: {
  OPC_CheckPredicate, 1,                     // 2333:   check predicate 1
  OPC_Decode, 148, 8, 108,                   // 2335:   decode to BLTZ_MM using decoder 108
                                             // 2335:  }
  1, 6,                                      // 2339:  case 0x1: {
  OPC_CheckPredicate, 1,                     // 2341:   check predicate 1
  OPC_Decode, 143, 8, 108,                   // 2343:   decode to BLTZAL_MM using decoder 108
                                             // 2343:  }
  2, 6,                                      // 2347:  case 0x2: {
  OPC_CheckPredicate, 1,                     // 2349:   check predicate 1
  OPC_Decode, 219, 7, 108,                   // 2351:   decode to BGEZ_MM using decoder 108
                                             // 2351:  }
  3, 6,                                      // 2355:  case 0x3: {
  OPC_CheckPredicate, 1,                     // 2357:   check predicate 1
  OPC_Decode, 214, 7, 108,                   // 2359:   decode to BGEZAL_MM using decoder 108
                                             // 2359:  }
  4, 6,                                      // 2363:  case 0x4: {
  OPC_CheckPredicate, 1,                     // 2365:   check predicate 1
  OPC_Decode, 129, 8, 108,                   // 2367:   decode to BLEZ_MM using decoder 108
                                             // 2367:  }
  5, 6,                                      // 2371:  case 0x5: {
  OPC_CheckPredicate, 1,                     // 2373:   check predicate 1
  OPC_Decode, 173, 8, 108,                   // 2375:   decode to BNEZC_MM using decoder 108
                                             // 2375:  }
  6, 6,                                      // 2379:  case 0x6: {
  OPC_CheckPredicate, 1,                     // 2381:   check predicate 1
  OPC_Decode, 228, 7, 108,                   // 2383:   decode to BGTZ_MM using decoder 108
                                             // 2383:  }
  7, 6,                                      // 2387:  case 0x7: {
  OPC_CheckPredicate, 1,                     // 2389:   check predicate 1
  OPC_Decode, 198, 7, 108,                   // 2391:   decode to BEQZC_MM using decoder 108
                                             // 2391:  }
  8, 6,                                      // 2395:  case 0x8: {
  OPC_CheckPredicate, 1,                     // 2397:   check predicate 1
  OPC_Decode, 180, 22, 109,                  // 2399:   decode to TLTI_MM using decoder 109
                                             // 2399:  }
  9, 6,                                      // 2403:  case 0x9: {
  OPC_CheckPredicate, 1,                     // 2405:   check predicate 1
  OPC_Decode, 149, 22, 109,                  // 2407:   decode to TGEI_MM using decoder 109
                                             // 2407:  }
  10, 6,                                     // 2411:  case 0xa: {
  OPC_CheckPredicate, 1,                     // 2413:   check predicate 1
  OPC_Decode, 179, 22, 109,                  // 2415:   decode to TLTIU_MM using decoder 109
                                             // 2415:  }
  11, 6,                                     // 2419:  case 0xb: {
  OPC_CheckPredicate, 1,                     // 2421:   check predicate 1
  OPC_Decode, 148, 22, 109,                  // 2423:   decode to TGEIU_MM using decoder 109
                                             // 2423:  }
  12, 6,                                     // 2427:  case 0xc: {
  OPC_CheckPredicate, 1,                     // 2429:   check predicate 1
  OPC_Decode, 186, 22, 109,                  // 2431:   decode to TNEI_MM using decoder 109
                                             // 2431:  }
  13, 6,                                     // 2435:  case 0xd: {
  OPC_CheckPredicate, 1,                     // 2437:   check predicate 1
  OPC_Decode, 169, 15, 110,                  // 2439:   decode to LUi_MM using decoder 110
                                             // 2439:  }
  14, 6,                                     // 2443:  case 0xe: {
  OPC_CheckPredicate, 1,                     // 2445:   check predicate 1
  OPC_Decode, 143, 22, 109,                  // 2447:   decode to TEQI_MM using decoder 109
                                             // 2447:  }
  16, 6,                                     // 2451:  case 0x10: {
  OPC_CheckPredicate, 1,                     // 2453:   check predicate 1
  OPC_Decode, 242, 21, 111,                  // 2455:   decode to SYNCI_MM using decoder 111
                                             // 2455:  }
  17, 6,                                     // 2459:  case 0x11: {
  OPC_CheckPredicate, 1,                     // 2461:   check predicate 1
  OPC_Decode, 142, 8, 108,                   // 2463:   decode to BLTZALS_MM using decoder 108
                                             // 2463:  }
  19, 6,                                     // 2467:  case 0x13: {
  OPC_CheckPredicate, 1,                     // 2469:   check predicate 1
  OPC_Decode, 213, 7, 108,                   // 2471:   decode to BGEZALS_MM using decoder 108
                                             // 2471:  }
  25, 10,                                    // 2475:  case 0x19: {
  OPC_CheckPredicate, 12,                    // 2477:   check predicate 12
  OPC_CheckField, 16, 5, 0,                  // 2479:   check Inst[20:16] == 0x0
  OPC_Decode, 186, 8, 112,                   // 2483:   decode to BPOSGE32C_MMR3 using decoder 112
                                             // 2483:  }
  27, 10,                                    // 2487:  case 0x1b: {
  OPC_CheckPredicate, 13,                    // 2489:   check predicate 13
  OPC_CheckField, 16, 5, 0,                  // 2491:   check Inst[20:16] == 0x0
  OPC_Decode, 187, 8, 113,                   // 2495:   decode to BPOSGE32_MM using decoder 113
                                             // 2495:  }
  28, 10,                                    // 2499:  case 0x1c: {
  OPC_CheckPredicate, 14,                    // 2501:   check predicate 14
  OPC_CheckField, 16, 2, 0,                  // 2503:   check Inst[17:16] == 0x0
  OPC_Decode, 167, 7, 114,                   // 2507:   decode to BC1F_MM using decoder 114
                                             // 2507:  }
  29, 0,                                     // 2511:  case 0x1d: {
  OPC_CheckPredicate, 14,                    // 2513:   check predicate 14
  OPC_CheckField, 16, 2, 0,                  // 2515:   check Inst[17:16] == 0x0
  OPC_Decode, 172, 7, 114,                   // 2519:   decode to BC1T_MM using decoder 114
                                             // 2519:  }
                                             // 2519:  } // switch Inst[25:21]
                                             // 2519: }
  20, 6,                                     // 2523: case 0x14: {
  OPC_CheckPredicate, 1,                     // 2525:  check predicate 1
  OPC_Decode, 175, 18, 115,                  // 2527:  decode to ORi_MM using decoder 115
                                             // 2527: }
  21, 145, 7,                                // 2531: case 0x15: {
  OPC_SwitchField, 0, 6,                     // 2534:  switch Inst[5:0] {
  1, 6,                                      // 2537:  case 0x1: {
  OPC_CheckPredicate, 15,                    // 2539:   check predicate 15
  OPC_Decode, 246, 15, 116,                  // 2541:   decode to MADD_S_MM using decoder 116
                                             // 2541:  }
  2, 6,                                      // 2545:  case 0x2: {
  OPC_CheckPredicate, 15,                    // 2547:   check predicate 15
  OPC_Decode, 148, 18, 116,                  // 2549:   decode to NMADD_S_MM using decoder 116
                                             // 2549:  }
  8, 35,                                     // 2553:  case 0x8: {
  OPC_SwitchField, 6, 5,                     // 2555:   switch Inst[10:6] {
  1, 6,                                      // 2558:   case 0x1: {
  OPC_CheckPredicate, 14,                    // 2560:    check predicate 14
  OPC_Decode, 205, 15, 117,                  // 2562:    decode to LWXC1_MM using decoder 117
                                             // 2562:   }
  2, 6,                                      // 2566:   case 0x2: {
  OPC_CheckPredicate, 14,                    // 2568:    check predicate 14
  OPC_Decode, 237, 21, 117,                  // 2570:    decode to SWXC1_MM using decoder 117
                                             // 2570:   }
  5, 6,                                      // 2574:   case 0x5: {
  OPC_CheckPredicate, 16,                    // 2576:    check predicate 16
  OPC_Decode, 166, 15, 118,                  // 2578:    decode to LUXC1_MM using decoder 118
                                             // 2578:   }
  6, 0,                                      // 2582:   case 0x6: {
  OPC_CheckPredicate, 16,                    // 2584:    check predicate 16
  OPC_Decode, 205, 21, 118,                  // 2586:    decode to SUXC1_MM using decoder 118
                                             // 2586:   }
                                             // 2586:   } // switch Inst[10:6]
                                             // 2586:  }
  9, 6,                                      // 2590:  case 0x9: {
  OPC_CheckPredicate, 17,                    // 2592:   check predicate 17
  OPC_Decode, 238, 15, 119,                  // 2594:   decode to MADD_D32_MM using decoder 119
                                             // 2594:  }
  10, 6,                                     // 2598:  case 0xa: {
  OPC_CheckPredicate, 17,                    // 2600:   check predicate 17
  OPC_Decode, 145, 18, 119,                  // 2602:   decode to NMADD_D32_MM using decoder 119
                                             // 2602:  }
  32, 59,                                    // 2606:  case 0x20: {
  OPC_SwitchField, 6, 5,                     // 2608:   switch Inst[10:6] {
  0, 10,                                     // 2611:   case 0x0: {
  OPC_CheckPredicate, 14,                    // 2613:    check predicate 14
  OPC_CheckField, 11, 2, 0,                  // 2615:    check Inst[12:11] == 0x0
  OPC_Decode, 240, 16, 120,                  // 2619:    decode to MOVF_S_MM using decoder 120
                                             // 2619:   }
  1, 10,                                     // 2623:   case 0x1: {
  OPC_CheckPredicate, 14,                    // 2625:    check predicate 14
  OPC_CheckField, 11, 2, 0,                  // 2627:    check Inst[12:11] == 0x0
  OPC_Decode, 132, 17, 120,                  // 2631:    decode to MOVT_S_MM using decoder 120
                                             // 2631:   }
  6, 6,                                      // 2635:   case 0x6: {
  OPC_CheckPredicate, 1,                     // 2637:    check predicate 1
  OPC_Decode, 238, 18, 121,                  // 2639:    decode to PREFX_MM using decoder 121
                                             // 2639:   }
  8, 10,                                     // 2643:   case 0x8: {
  OPC_CheckPredicate, 18,                    // 2645:    check predicate 18
  OPC_CheckField, 11, 2, 0,                  // 2647:    check Inst[12:11] == 0x0
  OPC_Decode, 234, 16, 122,                  // 2651:    decode to MOVF_D32_MM using decoder 122
                                             // 2651:   }
  9, 0,                                      // 2655:   case 0x9: {
  OPC_CheckPredicate, 18,                    // 2657:    check predicate 18
  OPC_CheckField, 11, 2, 0,                  // 2659:    check Inst[12:11] == 0x0
  OPC_Decode, 254, 16, 122,                  // 2663:    decode to MOVT_D32_MM using decoder 122
                                             // 2663:   }
                                             // 2663:   } // switch Inst[10:6]
                                             // 2663:  }
  33, 6,                                     // 2667:  case 0x21: {
  OPC_CheckPredicate, 15,                    // 2669:   check predicate 15
  OPC_Decode, 169, 17, 116,                  // 2671:   decode to MSUB_S_MM using decoder 116
                                             // 2671:  }
  34, 6,                                     // 2675:  case 0x22: {
  OPC_CheckPredicate, 15,                    // 2677:   check predicate 15
  OPC_Decode, 153, 18, 116,                  // 2679:   decode to NMSUB_S_MM using decoder 116
                                             // 2679:  }
  41, 6,                                     // 2683:  case 0x29: {
  OPC_CheckPredicate, 17,                    // 2685:   check predicate 17
  OPC_Decode, 161, 17, 119,                  // 2687:   decode to MSUB_D32_MM using decoder 119
                                             // 2687:  }
  42, 6,                                     // 2691:  case 0x2a: {
  OPC_CheckPredicate, 17,                    // 2693:   check predicate 17
  OPC_Decode, 150, 18, 119,                  // 2695:   decode to NMSUB_D32_MM using decoder 119
                                             // 2695:  }
  48, 35,                                    // 2699:  case 0x30: {
  OPC_SwitchField, 6, 5,                     // 2701:   switch Inst[10:6] {
  4, 6,                                      // 2704:   case 0x4: {
  OPC_CheckPredicate, 19,                    // 2706:    check predicate 19
  OPC_Decode, 216, 12, 123,                  // 2708:    decode to FADD_D32_MM using decoder 123
                                             // 2708:   }
  5, 6,                                      // 2712:   case 0x5: {
  OPC_CheckPredicate, 19,                    // 2714:    check predicate 19
  OPC_Decode, 233, 13, 123,                  // 2716:    decode to FSUB_D32_MM using decoder 123
                                             // 2716:   }
  6, 6,                                      // 2720:   case 0x6: {
  OPC_CheckPredicate, 19,                    // 2722:    check predicate 19
  OPC_Decode, 189, 13, 123,                  // 2724:    decode to FMUL_D32_MM using decoder 123
                                             // 2724:   }
  7, 0,                                      // 2728:   case 0x7: {
  OPC_CheckPredicate, 19,                    // 2730:    check predicate 19
  OPC_Decode, 255, 12, 123,                  // 2732:    decode to FDIV_D32_MM using decoder 123
                                             // 2732:   }
                                             // 2732:   } // switch Inst[10:6]
                                             // 2732:  }
  56, 35,                                    // 2736:  case 0x38: {
  OPC_SwitchField, 6, 4,                     // 2738:   switch Inst[9:6] {
  0, 6,                                      // 2741:   case 0x0: {
  OPC_CheckPredicate, 14,                    // 2743:    check predicate 14
  OPC_Decode, 252, 16, 124,                  // 2745:    decode to MOVN_I_S_MM using decoder 124
                                             // 2745:   }
  1, 6,                                      // 2749:   case 0x1: {
  OPC_CheckPredicate, 14,                    // 2751:    check predicate 14
  OPC_Decode, 144, 17, 124,                  // 2753:    decode to MOVZ_I_S_MM using decoder 124
                                             // 2753:   }
  4, 6,                                      // 2757:   case 0x4: {
  OPC_CheckPredicate, 18,                    // 2759:    check predicate 18
  OPC_Decode, 246, 16, 125,                  // 2761:    decode to MOVN_I_D32_MM using decoder 125
                                             // 2761:   }
  5, 0,                                      // 2765:   case 0x5: {
  OPC_CheckPredicate, 18,                    // 2767:    check predicate 18
  OPC_Decode, 138, 17, 125,                  // 2769:    decode to MOVZ_I_D32_MM using decoder 125
                                             // 2769:   }
                                             // 2769:   } // switch Inst[9:6]
                                             // 2769:  }
  59, 250, 2,                                // 2773:  case 0x3b: {
  OPC_SwitchField, 6, 7,                     // 2776:   switch Inst[12:6] {
  0, 10,                                     // 2779:   case 0x0: {
  OPC_CheckPredicate, 20,                    // 2781:    check predicate 20
  OPC_CheckField, 13, 3, 1,                  // 2783:    check Inst[15:13] == 0x1
  OPC_Decode, 159, 16, 126,                  // 2787:    decode to MFC1_MM using decoder 126
                                             // 2787:   }
  1, 10,                                     // 2791:   case 0x1: {
  OPC_CheckPredicate, 19,                    // 2793:    check predicate 19
  OPC_CheckField, 13, 3, 1,                  // 2795:    check Inst[15:13] == 0x1
  OPC_Decode, 178, 13, 127,                  // 2799:    decode to FMOV_D32_MM using decoder 127
                                             // 2799:   }
  4, 21,                                     // 2803:   case 0x4: {
  OPC_SwitchField, 13, 3,                    // 2805:    switch Inst[15:13] {
  0, 7,                                      // 2808:    case 0x0: {
  OPC_CheckPredicate, 21,                    // 2810:     check predicate 21
  OPC_Decode, 161, 10, 128, 1,               // 2812:     decode to CVT_L_S_MM using decoder 128
                                             // 2812:    }
  2, 0,                                      // 2817:    case 0x2: {
  OPC_CheckPredicate, 21,                    // 2819:     check predicate 21
  OPC_Decode, 158, 10, 129, 1,               // 2821:     decode to CVT_L_D64_MM using decoder 129
                                             // 2821:    }
                                             // 2821:    } // switch Inst[15:13]
                                             // 2821:   }
  5, 7,                                      // 2826:   case 0x5: {
  OPC_CheckPredicate, 14,                    // 2828:    check predicate 14
  OPC_Decode, 238, 16, 130, 1,               // 2830:    decode to MOVF_I_MM using decoder 130
                                             // 2830:   }
  8, 20,                                     // 2835:   case 0x8: {
  OPC_SwitchField, 13, 3,                    // 2837:    switch Inst[15:13] {
  0, 7,                                      // 2840:    case 0x0: {
  OPC_CheckPredicate, 20,                    // 2842:     check predicate 20
  OPC_Decode, 165, 19, 131, 1,               // 2844:     decode to RSQRT_S_MM using decoder 131
                                             // 2844:    }
  2, 0,                                      // 2849:    case 0x2: {
  OPC_CheckPredicate, 19,                    // 2851:     check predicate 19
  OPC_Decode, 161, 19, 127,                  // 2853:     decode to RSQRT_D32_MM using decoder 127
                                             // 2853:    }
                                             // 2853:    } // switch Inst[15:13]
                                             // 2853:   }
  13, 20,                                    // 2857:   case 0xd: {
  OPC_SwitchField, 13, 3,                    // 2859:    switch Inst[15:13] {
  0, 7,                                      // 2862:    case 0x0: {
  OPC_CheckPredicate, 20,                    // 2864:     check predicate 20
  OPC_Decode, 213, 12, 131, 1,               // 2866:     decode to FABS_S_MM using decoder 131
                                             // 2866:    }
  1, 0,                                      // 2871:    case 0x1: {
  OPC_CheckPredicate, 19,                    // 2873:     check predicate 19
  OPC_Decode, 209, 12, 127,                  // 2875:     decode to FABS_D32_MM using decoder 127
                                             // 2875:    }
                                             // 2875:    } // switch Inst[15:13]
                                             // 2875:   }
  32, 11,                                    // 2879:   case 0x20: {
  OPC_CheckPredicate, 20,                    // 2881:    check predicate 20
  OPC_CheckField, 13, 3, 1,                  // 2883:    check Inst[15:13] == 0x1
  OPC_Decode, 175, 17, 132, 1,               // 2887:    decode to MTC1_MM using decoder 132
                                             // 2887:   }
  36, 21,                                    // 2892:   case 0x24: {
  OPC_SwitchField, 13, 3,                    // 2894:    switch Inst[15:13] {
  0, 7,                                      // 2897:    case 0x0: {
  OPC_CheckPredicate, 20,                    // 2899:     check predicate 20
  OPC_Decode, 182, 10, 131, 1,               // 2901:     decode to CVT_W_S_MM using decoder 131
                                             // 2901:    }
  2, 0,                                      // 2906:    case 0x2: {
  OPC_CheckPredicate, 19,                    // 2908:     check predicate 19
  OPC_Decode, 178, 10, 133, 1,               // 2910:     decode to CVT_W_D32_MM using decoder 133
                                             // 2910:    }
                                             // 2910:    } // switch Inst[15:13]
                                             // 2910:   }
  37, 7,                                     // 2915:   case 0x25: {
  OPC_CheckPredicate, 14,                    // 2917:    check predicate 14
  OPC_Decode, 130, 17, 130, 1,               // 2919:    decode to MOVT_I_MM using decoder 130
                                             // 2919:   }
  40, 20,                                    // 2924:   case 0x28: {
  OPC_SwitchField, 13, 3,                    // 2926:    switch Inst[15:13] {
  0, 7,                                      // 2929:    case 0x0: {
  OPC_CheckPredicate, 20,                    // 2931:     check predicate 20
  OPC_Decode, 229, 13, 131, 1,               // 2933:     decode to FSQRT_S_MM using decoder 131
                                             // 2933:    }
  2, 0,                                      // 2938:    case 0x2: {
  OPC_CheckPredicate, 19,                    // 2940:     check predicate 19
  OPC_Decode, 225, 13, 127,                  // 2942:     decode to FSQRT_D32_MM using decoder 127
                                             // 2942:    }
                                             // 2942:    } // switch Inst[15:13]
                                             // 2942:   }
  44, 39,                                    // 2946:   case 0x2c: {
  OPC_SwitchField, 13, 3,                    // 2948:    switch Inst[15:13] {
  0, 7,                                      // 2951:    case 0x0: {
  OPC_CheckPredicate, 20,                    // 2953:     check predicate 20
  OPC_Decode, 165, 13, 131, 1,               // 2955:     decode to FLOOR_W_S_MM using decoder 131
                                             // 2955:    }
  1, 7,                                      // 2960:    case 0x1: {
  OPC_CheckPredicate, 20,                    // 2962:     check predicate 20
  OPC_Decode, 197, 22, 131, 1,               // 2964:     decode to TRUNC_W_S_MM using decoder 131
                                             // 2964:    }
  2, 7,                                      // 2969:    case 0x2: {
  OPC_CheckPredicate, 19,                    // 2971:     check predicate 19
  OPC_Decode, 163, 13, 133, 1,               // 2973:     decode to FLOOR_W_MM using decoder 133
                                             // 2973:    }
  3, 0,                                      // 2978:    case 0x3: {
  OPC_CheckPredicate, 19,                    // 2980:     check predicate 19
  OPC_Decode, 195, 22, 133, 1,               // 2982:     decode to TRUNC_W_MM using decoder 133
                                             // 2982:    }
                                             // 2982:    } // switch Inst[15:13]
                                             // 2982:   }
  45, 10,                                    // 2987:   case 0x2d: {
  OPC_CheckPredicate, 19,                    // 2989:    check predicate 19
  OPC_CheckField, 13, 3, 1,                  // 2991:    check Inst[15:13] == 0x1
  OPC_Decode, 198, 13, 127,                  // 2995:    decode to FNEG_D32_MM using decoder 127
                                             // 2995:   }
  64, 21,                                    // 2999:   case 0x40: {
  OPC_SwitchField, 13, 3,                    // 3001:    switch Inst[15:13] {
  0, 7,                                      // 3004:    case 0x0: {
  OPC_CheckPredicate, 20,                    // 3006:     check predicate 20
  OPC_Decode, 245, 8, 134, 1,                // 3008:     decode to CFC1_MM using decoder 134
                                             // 3008:    }
  1, 0,                                      // 3013:    case 0x1: {
  OPC_CheckPredicate, 19,                    // 3015:     check predicate 19
  OPC_Decode, 167, 16, 135, 1,               // 3017:     decode to MFHC1_D32_MM using decoder 135
                                             // 3017:    }
                                             // 3017:    } // switch Inst[15:13]
                                             // 3017:   }
  72, 20,                                    // 3022:   case 0x48: {
  OPC_SwitchField, 13, 3,                    // 3024:    switch Inst[15:13] {
  0, 7,                                      // 3027:    case 0x0: {
  OPC_CheckPredicate, 20,                    // 3029:     check predicate 20
  OPC_Decode, 132, 19, 131, 1,               // 3031:     decode to RECIP_S_MM using decoder 131
                                             // 3031:    }
  2, 0,                                      // 3036:    case 0x2: {
  OPC_CheckPredicate, 19,                    // 3038:     check predicate 19
  OPC_Decode, 128, 19, 127,                  // 3040:     decode to RECIP_D32_MM using decoder 127
                                             // 3040:    }
                                             // 3040:    } // switch Inst[15:13]
                                             // 3040:   }
  77, 21,                                    // 3044:   case 0x4d: {
  OPC_SwitchField, 13, 3,                    // 3046:    switch Inst[15:13] {
  0, 7,                                      // 3049:    case 0x0: {
  OPC_CheckPredicate, 19,                    // 3051:     check predicate 19
  OPC_Decode, 148, 10, 136, 1,               // 3053:     decode to CVT_D32_S_MM using decoder 136
                                             // 3053:    }
  1, 0,                                      // 3058:    case 0x1: {
  OPC_CheckPredicate, 19,                    // 3060:     check predicate 19
  OPC_Decode, 150, 10, 136, 1,               // 3062:     decode to CVT_D32_W_MM using decoder 136
                                             // 3062:    }
                                             // 3062:    } // switch Inst[15:13]
                                             // 3062:   }
  96, 21,                                    // 3067:   case 0x60: {
  OPC_SwitchField, 13, 3,                    // 3069:    switch Inst[15:13] {
  0, 7,                                      // 3072:    case 0x0: {
  OPC_CheckPredicate, 20,                    // 3074:     check predicate 20
  OPC_Decode, 144, 10, 137, 1,               // 3076:     decode to CTC1_MM using decoder 137
                                             // 3076:    }
  1, 0,                                      // 3081:    case 0x1: {
  OPC_CheckPredicate, 19,                    // 3083:     check predicate 19
  OPC_Decode, 183, 17, 138, 1,               // 3085:     decode to MTHC1_D32_MM using decoder 138
                                             // 3085:    }
                                             // 3085:    } // switch Inst[15:13]
                                             // 3085:   }
  108, 39,                                   // 3090:   case 0x6c: {
  OPC_SwitchField, 13, 3,                    // 3092:    switch Inst[15:13] {
  0, 7,                                      // 3095:    case 0x0: {
  OPC_CheckPredicate, 20,                    // 3097:     check predicate 20
  OPC_Decode, 234, 8, 131, 1,                // 3099:     decode to CEIL_W_S_MM using decoder 131
                                             // 3099:    }
  1, 7,                                      // 3104:    case 0x1: {
  OPC_CheckPredicate, 20,                    // 3106:     check predicate 20
  OPC_Decode, 158, 19, 131, 1,               // 3108:     decode to ROUND_W_S_MM using decoder 131
                                             // 3108:    }
  2, 7,                                      // 3113:    case 0x2: {
  OPC_CheckPredicate, 19,                    // 3115:     check predicate 19
  OPC_Decode, 232, 8, 133, 1,                // 3117:     decode to CEIL_W_MM using decoder 133
                                             // 3117:    }
  3, 0,                                      // 3122:    case 0x3: {
  OPC_CheckPredicate, 19,                    // 3124:     check predicate 19
  OPC_Decode, 156, 19, 133, 1,               // 3126:     decode to ROUND_W_MM using decoder 133
                                             // 3126:    }
                                             // 3126:    } // switch Inst[15:13]
                                             // 3126:   }
  109, 0,                                    // 3131:   case 0x6d: {
  OPC_SwitchField, 13, 3,                    // 3133:    switch Inst[15:13] {
  0, 7,                                      // 3136:    case 0x0: {
  OPC_CheckPredicate, 19,                    // 3138:     check predicate 19
  OPC_Decode, 167, 10, 133, 1,               // 3140:     decode to CVT_S_D32_MM using decoder 133
                                             // 3140:    }
  1, 0,                                      // 3145:    case 0x1: {
  OPC_CheckPredicate, 20,                    // 3147:     check predicate 20
  OPC_Decode, 175, 10, 131, 1,               // 3149:     decode to CVT_S_W_MM using decoder 131
                                             // 3149:    }
                                             // 3149:    } // switch Inst[15:13]
                                             // 3149:   }
                                             // 3149:   } // switch Inst[12:6]
                                             // 3149:  }
  60, 0,                                     // 3154:  case 0x3c: {
  OPC_SwitchField, 6, 7,                     // 3156:   switch Inst[12:6] {
  0, 7,                                      // 3159:   case 0x0: {
  OPC_CheckPredicate, 14,                    // 3161:    check predicate 14
  OPC_Decode, 195, 10, 139, 1,               // 3163:    decode to C_F_S_MM using decoder 139
                                             // 3163:   }
  1, 7,                                      // 3168:   case 0x1: {
  OPC_CheckPredicate, 14,                    // 3170:    check predicate 14
  OPC_Decode, 151, 11, 139, 1,               // 3172:    decode to C_UN_S_MM using decoder 139
                                             // 3172:   }
  2, 7,                                      // 3177:   case 0x2: {
  OPC_CheckPredicate, 14,                    // 3179:    check predicate 14
  OPC_Decode, 189, 10, 139, 1,               // 3181:    decode to C_EQ_S_MM using decoder 139
                                             // 3181:   }
  3, 7,                                      // 3186:   case 0x3: {
  OPC_CheckPredicate, 14,                    // 3188:    check predicate 14
  OPC_Decode, 133, 11, 139, 1,               // 3190:    decode to C_UEQ_S_MM using decoder 139
                                             // 3190:   }
  4, 7,                                      // 3195:   case 0x4: {
  OPC_CheckPredicate, 14,                    // 3197:    check predicate 14
  OPC_Decode, 243, 10, 139, 1,               // 3199:    decode to C_OLT_S_MM using decoder 139
                                             // 3199:   }
  5, 7,                                      // 3204:   case 0x5: {
  OPC_CheckPredicate, 14,                    // 3206:    check predicate 14
  OPC_Decode, 145, 11, 139, 1,               // 3208:    decode to C_ULT_S_MM using decoder 139
                                             // 3208:   }
  6, 7,                                      // 3213:   case 0x6: {
  OPC_CheckPredicate, 14,                    // 3215:    check predicate 14
  OPC_Decode, 237, 10, 139, 1,               // 3217:    decode to C_OLE_S_MM using decoder 139
                                             // 3217:   }
  7, 7,                                      // 3222:   case 0x7: {
  OPC_CheckPredicate, 14,                    // 3224:    check predicate 14
  OPC_Decode, 139, 11, 139, 1,               // 3226:    decode to C_ULE_S_MM using decoder 139
                                             // 3226:   }
  8, 7,                                      // 3231:   case 0x8: {
  OPC_CheckPredicate, 14,                    // 3233:    check predicate 14
  OPC_Decode, 255, 10, 139, 1,               // 3235:    decode to C_SF_S_MM using decoder 139
                                             // 3235:   }
  9, 7,                                      // 3240:   case 0x9: {
  OPC_CheckPredicate, 14,                    // 3242:    check predicate 14
  OPC_Decode, 219, 10, 139, 1,               // 3244:    decode to C_NGLE_S_MM using decoder 139
                                             // 3244:   }
  10, 7,                                     // 3249:   case 0xa: {
  OPC_CheckPredicate, 14,                    // 3251:    check predicate 14
  OPC_Decode, 249, 10, 139, 1,               // 3253:    decode to C_SEQ_S_MM using decoder 139
                                             // 3253:   }
  11, 7,                                     // 3258:   case 0xb: {
  OPC_CheckPredicate, 14,                    // 3260:    check predicate 14
  OPC_Decode, 225, 10, 139, 1,               // 3262:    decode to C_NGL_S_MM using decoder 139
                                             // 3262:   }
  12, 7,                                     // 3267:   case 0xc: {
  OPC_CheckPredicate, 14,                    // 3269:    check predicate 14
  OPC_Decode, 207, 10, 139, 1,               // 3271:    decode to C_LT_S_MM using decoder 139
                                             // 3271:   }
  13, 7,                                     // 3276:   case 0xd: {
  OPC_CheckPredicate, 14,                    // 3278:    check predicate 14
  OPC_Decode, 213, 10, 139, 1,               // 3280:    decode to C_NGE_S_MM using decoder 139
                                             // 3280:   }
  14, 7,                                     // 3285:   case 0xe: {
  OPC_CheckPredicate, 14,                    // 3287:    check predicate 14
  OPC_Decode, 201, 10, 139, 1,               // 3289:    decode to C_LE_S_MM using decoder 139
                                             // 3289:   }
  15, 7,                                     // 3294:   case 0xf: {
  OPC_CheckPredicate, 14,                    // 3296:    check predicate 14
  OPC_Decode, 231, 10, 139, 1,               // 3298:    decode to C_NGT_S_MM using decoder 139
                                             // 3298:   }
  16, 7,                                     // 3303:   case 0x10: {
  OPC_CheckPredicate, 18,                    // 3305:    check predicate 18
  OPC_Decode, 191, 10, 140, 1,               // 3307:    decode to C_F_D32_MM using decoder 140
                                             // 3307:   }
  17, 7,                                     // 3312:   case 0x11: {
  OPC_CheckPredicate, 18,                    // 3314:    check predicate 18
  OPC_Decode, 147, 11, 140, 1,               // 3316:    decode to C_UN_D32_MM using decoder 140
                                             // 3316:   }
  18, 7,                                     // 3321:   case 0x12: {
  OPC_CheckPredicate, 18,                    // 3323:    check predicate 18
  OPC_Decode, 185, 10, 140, 1,               // 3325:    decode to C_EQ_D32_MM using decoder 140
                                             // 3325:   }
  19, 7,                                     // 3330:   case 0x13: {
  OPC_CheckPredicate, 18,                    // 3332:    check predicate 18
  OPC_Decode, 129, 11, 140, 1,               // 3334:    decode to C_UEQ_D32_MM using decoder 140
                                             // 3334:   }
  20, 7,                                     // 3339:   case 0x14: {
  OPC_CheckPredicate, 18,                    // 3341:    check predicate 18
  OPC_Decode, 239, 10, 140, 1,               // 3343:    decode to C_OLT_D32_MM using decoder 140
                                             // 3343:   }
  21, 7,                                     // 3348:   case 0x15: {
  OPC_CheckPredicate, 18,                    // 3350:    check predicate 18
  OPC_Decode, 141, 11, 140, 1,               // 3352:    decode to C_ULT_D32_MM using decoder 140
                                             // 3352:   }
  22, 7,                                     // 3357:   case 0x16: {
  OPC_CheckPredicate, 18,                    // 3359:    check predicate 18
  OPC_Decode, 233, 10, 140, 1,               // 3361:    decode to C_OLE_D32_MM using decoder 140
                                             // 3361:   }
  23, 7,                                     // 3366:   case 0x17: {
  OPC_CheckPredicate, 18,                    // 3368:    check predicate 18
  OPC_Decode, 135, 11, 140, 1,               // 3370:    decode to C_ULE_D32_MM using decoder 140
                                             // 3370:   }
  24, 7,                                     // 3375:   case 0x18: {
  OPC_CheckPredicate, 18,                    // 3377:    check predicate 18
  OPC_Decode, 251, 10, 140, 1,               // 3379:    decode to C_SF_D32_MM using decoder 140
                                             // 3379:   }
  25, 7,                                     // 3384:   case 0x19: {
  OPC_CheckPredicate, 18,                    // 3386:    check predicate 18
  OPC_Decode, 215, 10, 140, 1,               // 3388:    decode to C_NGLE_D32_MM using decoder 140
                                             // 3388:   }
  26, 7,                                     // 3393:   case 0x1a: {
  OPC_CheckPredicate, 18,                    // 3395:    check predicate 18
  OPC_Decode, 245, 10, 140, 1,               // 3397:    decode to C_SEQ_D32_MM using decoder 140
                                             // 3397:   }
  27, 7,                                     // 3402:   case 0x1b: {
  OPC_CheckPredicate, 18,                    // 3404:    check predicate 18
  OPC_Decode, 221, 10, 140, 1,               // 3406:    decode to C_NGL_D32_MM using decoder 140
                                             // 3406:   }
  28, 7,                                     // 3411:   case 0x1c: {
  OPC_CheckPredicate, 18,                    // 3413:    check predicate 18
  OPC_Decode, 203, 10, 140, 1,               // 3415:    decode to C_LT_D32_MM using decoder 140
                                             // 3415:   }
  29, 7,                                     // 3420:   case 0x1d: {
  OPC_CheckPredicate, 18,                    // 3422:    check predicate 18
  OPC_Decode, 209, 10, 140, 1,               // 3424:    decode to C_NGE_D32_MM using decoder 140
                                             // 3424:   }
  30, 7,                                     // 3429:   case 0x1e: {
  OPC_CheckPredicate, 18,                    // 3431:    check predicate 18
  OPC_Decode, 197, 10, 140, 1,               // 3433:    decode to C_LE_D32_MM using decoder 140
                                             // 3433:   }
  31, 0,                                     // 3438:   case 0x1f: {
  OPC_CheckPredicate, 18,                    // 3440:    check predicate 18
  OPC_Decode, 227, 10, 140, 1,               // 3442:    decode to C_NGT_D32_MM using decoder 140
                                             // 3442:   }
                                             // 3442:   } // switch Inst[12:6]
                                             // 3442:  }
                                             // 3442:  } // switch Inst[5:0]
                                             // 3442: }
  22, 30,                                    // 3447: case 0x16: {
  OPC_SwitchField, 0, 11,                    // 3449:  switch Inst[10:0] {
  197, 1, 6,                                 // 3452:  case 0xc5: {
  OPC_CheckPredicate, 9,                     // 3455:   check predicate 9
  OPC_Decode, 175, 9, 60,                    // 3457:   decode to CMPGU_EQ_QB_MM using decoder 60
                                             // 3457:  }
  133, 2, 6,                                 // 3461:  case 0x105: {
  OPC_CheckPredicate, 9,                     // 3464:   check predicate 9
  OPC_Decode, 179, 9, 60,                    // 3466:   decode to CMPGU_LT_QB_MM using decoder 60
                                             // 3466:  }
  197, 2, 0,                                 // 3470:  case 0x145: {
  OPC_CheckPredicate, 9,                     // 3473:   check predicate 9
  OPC_Decode, 177, 9, 60,                    // 3475:   decode to CMPGU_LE_QB_MM using decoder 60
                                             // 3475:  }
                                             // 3475:  } // switch Inst[10:0]
                                             // 3475: }
  24, 221, 1,                                // 3479: case 0x18: {
  OPC_SwitchField, 12, 4,                    // 3482:  switch Inst[15:12] {
  0, 6,                                      // 3485:  case 0x0: {
  OPC_CheckPredicate, 1,                     // 3487:   check predicate 1
  OPC_Decode, 188, 15, 106,                  // 3489:   decode to LWL_MM using decoder 106
                                             // 3489:  }
  1, 6,                                      // 3493:  case 0x1: {
  OPC_CheckPredicate, 1,                     // 3495:   check predicate 1
  OPC_Decode, 199, 15, 106,                  // 3497:   decode to LWR_MM using decoder 106
                                             // 3497:  }
  2, 6,                                      // 3501:  case 0x2: {
  OPC_CheckPredicate, 1,                     // 3503:   check predicate 1
  OPC_Decode, 239, 18, 107,                  // 3505:   decode to PREF_MM using decoder 107
                                             // 3505:  }
  3, 6,                                      // 3509:  case 0x3: {
  OPC_CheckPredicate, 1,                     // 3511:   check predicate 1
  OPC_Decode, 157, 15, 106,                  // 3513:   decode to LL_MM using decoder 106
                                             // 3513:  }
  6, 75,                                     // 3517:  case 0x6: {
  OPC_SwitchField, 9, 3,                     // 3519:   switch Inst[11:9] {
  0, 7,                                      // 3522:   case 0x0: {
  OPC_CheckPredicate, 22,                    // 3524:    check predicate 22
  OPC_Decode, 235, 14, 141, 1,               // 3526:    decode to LBuE_MM using decoder 141
                                             // 3526:   }
  1, 7,                                      // 3531:   case 0x1: {
  OPC_CheckPredicate, 22,                    // 3533:    check predicate 22
  OPC_Decode, 146, 15, 141, 1,               // 3535:    decode to LHuE_MM using decoder 141
                                             // 3535:   }
  2, 7,                                      // 3540:   case 0x2: {
  OPC_CheckPredicate, 23,                    // 3542:    check predicate 23
  OPC_Decode, 187, 15, 141, 1,               // 3544:    decode to LWLE_MM using decoder 141
                                             // 3544:   }
  3, 7,                                      // 3549:   case 0x3: {
  OPC_CheckPredicate, 23,                    // 3551:    check predicate 23
  OPC_Decode, 198, 15, 141, 1,               // 3553:    decode to LWRE_MM using decoder 141
                                             // 3553:   }
  4, 7,                                      // 3558:   case 0x4: {
  OPC_CheckPredicate, 22,                    // 3560:    check predicate 22
  OPC_Decode, 225, 14, 141, 1,               // 3562:    decode to LBE_MM using decoder 141
                                             // 3562:   }
  5, 7,                                      // 3567:   case 0x5: {
  OPC_CheckPredicate, 22,                    // 3569:    check predicate 22
  OPC_Decode, 138, 15, 141, 1,               // 3571:    decode to LHE_MM using decoder 141
                                             // 3571:   }
  6, 7,                                      // 3576:   case 0x6: {
  OPC_CheckPredicate, 22,                    // 3578:    check predicate 22
  OPC_Decode, 156, 15, 141, 1,               // 3580:    decode to LLE_MM using decoder 141
                                             // 3580:   }
  7, 0,                                      // 3585:   case 0x7: {
  OPC_CheckPredicate, 22,                    // 3587:    check predicate 22
  OPC_Decode, 182, 15, 141, 1,               // 3589:    decode to LWE_MM using decoder 141
                                             // 3589:   }
                                             // 3589:   } // switch Inst[11:9]
                                             // 3589:  }
  8, 6,                                      // 3594:  case 0x8: {
  OPC_CheckPredicate, 1,                     // 3596:   check predicate 1
  OPC_Decode, 224, 21, 106,                  // 3598:   decode to SWL_MM using decoder 106
                                             // 3598:  }
  9, 6,                                      // 3602:  case 0x9: {
  OPC_CheckPredicate, 1,                     // 3604:   check predicate 1
  OPC_Decode, 233, 21, 106,                  // 3606:   decode to SWR_MM using decoder 106
                                             // 3606:  }
  10, 75,                                    // 3610:  case 0xa: {
  OPC_SwitchField, 9, 3,                     // 3612:   switch Inst[11:9] {
  0, 7,                                      // 3615:   case 0x0: {
  OPC_CheckPredicate, 23,                    // 3617:    check predicate 23
  OPC_Decode, 223, 21, 141, 1,               // 3619:    decode to SWLE_MM using decoder 141
                                             // 3619:   }
  1, 7,                                      // 3624:   case 0x1: {
  OPC_CheckPredicate, 23,                    // 3626:    check predicate 23
  OPC_Decode, 232, 21, 141, 1,               // 3628:    decode to SWRE_MM using decoder 141
                                             // 3628:   }
  2, 7,                                      // 3633:   case 0x2: {
  OPC_CheckPredicate, 22,                    // 3635:    check predicate 22
  OPC_Decode, 237, 18, 142, 1,               // 3637:    decode to PREFE_MM using decoder 142
                                             // 3637:   }
  3, 7,                                      // 3642:   case 0x3: {
  OPC_CheckPredicate, 22,                    // 3644:    check predicate 22
  OPC_Decode, 221, 8, 142, 1,                // 3646:    decode to CACHEE_MM using decoder 142
                                             // 3646:   }
  4, 7,                                      // 3651:   case 0x4: {
  OPC_CheckPredicate, 22,                    // 3653:    check predicate 22
  OPC_Decode, 183, 19, 141, 1,               // 3655:    decode to SBE_MM using decoder 141
                                             // 3655:   }
  5, 7,                                      // 3660:   case 0x5: {
  OPC_CheckPredicate, 22,                    // 3662:    check predicate 22
  OPC_Decode, 249, 19, 141, 1,               // 3664:    decode to SHE_MM using decoder 141
                                             // 3664:   }
  6, 7,                                      // 3669:   case 0x6: {
  OPC_CheckPredicate, 22,                    // 3671:    check predicate 22
  OPC_Decode, 192, 19, 141, 1,               // 3673:    decode to SCE_MM using decoder 141
                                             // 3673:   }
  7, 0,                                      // 3678:   case 0x7: {
  OPC_CheckPredicate, 22,                    // 3680:    check predicate 22
  OPC_Decode, 219, 21, 141, 1,               // 3682:    decode to SWE_MM using decoder 141
                                             // 3682:   }
                                             // 3682:   } // switch Inst[11:9]
                                             // 3682:  }
  11, 6,                                     // 3687:  case 0xb: {
  OPC_CheckPredicate, 1,                     // 3689:   check predicate 1
  OPC_Decode, 193, 19, 106,                  // 3691:   decode to SC_MM using decoder 106
                                             // 3691:  }
  14, 0,                                     // 3695:  case 0xe: {
  OPC_CheckPredicate, 1,                     // 3697:   check predicate 1
  OPC_Decode, 202, 15, 106,                  // 3699:   decode to LWU_MM using decoder 106
                                             // 3699:  }
                                             // 3699:  } // switch Inst[15:12]
                                             // 3699: }
  28, 6,                                     // 3703: case 0x1c: {
  OPC_CheckPredicate, 1,                     // 3705:  check predicate 1
  OPC_Decode, 229, 22, 115,                  // 3707:  decode to XORi_MM using decoder 115
                                             // 3707: }
  29, 7,                                     // 3711: case 0x1d: {
  OPC_CheckPredicate, 1,                     // 3713:  check predicate 1
  OPC_Decode, 193, 14, 143, 1,               // 3715:  decode to JALS_MM using decoder 143
                                             // 3715: }
  30, 7,                                     // 3720: case 0x1e: {
  OPC_CheckPredicate, 1,                     // 3722:  check predicate 1
  OPC_Decode, 148, 6, 144, 1,                // 3724:  decode to ADDIUPC_MM using decoder 144
                                             // 3724: }
  36, 6,                                     // 3729: case 0x24: {
  OPC_CheckPredicate, 2,                     // 3731:  check predicate 2
  OPC_Decode, 207, 20, 104,                  // 3733:  decode to SLTi_MM using decoder 104
                                             // 3733: }
  37, 7,                                     // 3737: case 0x25: {
  OPC_CheckPredicate, 1,                     // 3739:  check predicate 1
  OPC_Decode, 200, 7, 145, 1,                // 3741:  decode to BEQ_MM using decoder 145
                                             // 3741: }
  38, 7,                                     // 3746: case 0x26: {
  OPC_CheckPredicate, 20,                    // 3748:  check predicate 20
  OPC_Decode, 211, 21, 146, 1,               // 3750:  decode to SWC1_MM using decoder 146
                                             // 3750: }
  39, 7,                                     // 3755: case 0x27: {
  OPC_CheckPredicate, 20,                    // 3757:  check predicate 20
  OPC_Decode, 174, 15, 146, 1,               // 3759:  decode to LWC1_MM using decoder 146
                                             // 3759: }
  44, 6,                                     // 3764: case 0x2c: {
  OPC_CheckPredicate, 2,                     // 3766:  check predicate 2
  OPC_Decode, 210, 20, 104,                  // 3768:  decode to SLTiu_MM using decoder 104
                                             // 3768: }
  45, 7,                                     // 3772: case 0x2d: {
  OPC_CheckPredicate, 1,                     // 3774:  check predicate 1
  OPC_Decode, 175, 8, 145, 1,                // 3776:  decode to BNE_MM using decoder 145
                                             // 3776: }
  46, 7,                                     // 3781: case 0x2e: {
  OPC_CheckPredicate, 19,                    // 3783:  check predicate 19
  OPC_Decode, 206, 19, 146, 1,               // 3785:  decode to SDC1_MM_D32 using decoder 146
                                             // 3785: }
  47, 7,                                     // 3790: case 0x2f: {
  OPC_CheckPredicate, 19,                    // 3792:  check predicate 19
  OPC_Decode, 241, 14, 146, 1,               // 3794:  decode to LDC1_MM_D32 using decoder 146
                                             // 3794: }
  52, 6,                                     // 3799: case 0x34: {
  OPC_CheckPredicate, 1,                     // 3801:  check predicate 1
  OPC_Decode, 238, 6, 115,                   // 3803:  decode to ANDi_MM using decoder 115
                                             // 3803: }
  53, 7,                                     // 3807: case 0x35: {
  OPC_CheckPredicate, 1,                     // 3809:  check predicate 1
  OPC_Decode, 215, 14, 143, 1,               // 3811:  decode to J_MM using decoder 143
                                             // 3811: }
  60, 7,                                     // 3816: case 0x3c: {
  OPC_CheckPredicate, 1,                     // 3818:  check predicate 1
  OPC_Decode, 195, 14, 147, 1,               // 3820:  decode to JALX_MM using decoder 147
                                             // 3820: }
  61, 7,                                     // 3825: case 0x3d: {
  OPC_CheckPredicate, 1,                     // 3827:  check predicate 1
  OPC_Decode, 196, 14, 143, 1,               // 3829:  decode to JAL_MM using decoder 143
                                             // 3829: }
  62, 6,                                     // 3834: case 0x3e: {
  OPC_CheckPredicate, 2,                     // 3836:  check predicate 2
  OPC_Decode, 238, 21, 105,                  // 3838:  decode to SW_MM using decoder 105
                                             // 3838: }
  63, 0,                                     // 3842: case 0x3f: {
  OPC_CheckPredicate, 2,                     // 3844:  check predicate 2
  OPC_Decode, 208, 15, 105,                  // 3846:  decode to LW_MM using decoder 105
                                             // 3846: }
                                             // 3846: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMicroMipsDSP32[21] = {
  OPC_SwitchField, 26, 6,                    //  0: switch Inst[31:26] {
  62, 7,                                     //  3: case 0x3e: {
  OPC_CheckPredicate, 9,                     //  5:  check predicate 9
  OPC_Decode, 217, 21, 148, 1,               //  7:  decode to SWDSP_MM using decoder 148
                                             //  7: }
  63, 0,                                     // 12: case 0x3f: {
  OPC_CheckPredicate, 9,                     // 14:  check predicate 9
  OPC_Decode, 180, 15, 148, 1,               // 16:  decode to LWDSP_MM using decoder 148
                                             // 16: }
                                             // 16: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMicroMipsFP6432[210] = {
  OPC_SwitchField, 26, 6,                    //   0: switch Inst[31:26] {
  21, 186, 1,                                //   3: case 0x15: {
  OPC_SwitchField, 0, 11,                    //   6:  switch Inst[10:0] {
  59, 30,                                    //   9:  case 0x3b: {
  OPC_SwitchField, 11, 5,                    //  11:   switch Inst[15:11] {
  5, 7,                                      //  14:   case 0x5: {
  OPC_CheckPredicate, 21,                    //  16:    check predicate 21
  OPC_Decode, 174, 17, 149, 1,               //  18:    decode to MTC1_D64_MM using decoder 149
                                             //  18:   }
  6, 7,                                      //  23:   case 0x6: {
  OPC_CheckPredicate, 21,                    //  25:    check predicate 21
  OPC_Decode, 169, 16, 150, 1,               //  27:    decode to MFHC1_D64_MM using decoder 150
                                             //  27:   }
  7, 0,                                      //  32:   case 0x7: {
  OPC_CheckPredicate, 21,                    //  34:    check predicate 21
  OPC_Decode, 185, 17, 151, 1,               //  36:    decode to MTHC1_D64_MM using decoder 151
                                             //  36:   }
                                             //  36:   } // switch Inst[15:11]
                                             //  36:  }
  123, 11,                                   //  41:  case 0x7b: {
  OPC_CheckPredicate, 21,                    //  43:   check predicate 21
  OPC_CheckField, 11, 5, 4,                  //  45:   check Inst[15:11] == 0x4
  OPC_Decode, 180, 13, 129, 1,               //  49:   decode to FMOV_D64_MM using decoder 129
                                             //  49:  }
  176, 2, 7,                                 //  54:  case 0x130: {
  OPC_CheckPredicate, 21,                    //  57:   check predicate 21
  OPC_Decode, 218, 12, 152, 1,               //  59:   decode to FADD_D64_MM using decoder 152
                                             //  59:  }
  187, 2, 11,                                //  64:  case 0x13b: {
  OPC_CheckPredicate, 21,                    //  67:   check predicate 21
  OPC_CheckField, 11, 5, 9,                  //  69:   check Inst[15:11] == 0x9
  OPC_Decode, 180, 10, 153, 1,               //  73:   decode to CVT_W_D64_MM using decoder 153
                                             //  73:  }
  240, 2, 7,                                 //  78:  case 0x170: {
  OPC_CheckPredicate, 21,                    //  81:   check predicate 21
  OPC_Decode, 235, 13, 152, 1,               //  83:   decode to FSUB_D64_MM using decoder 152
                                             //  83:  }
  176, 3, 7,                                 //  88:  case 0x1b0: {
  OPC_CheckPredicate, 21,                    //  91:   check predicate 21
  OPC_Decode, 191, 13, 152, 1,               //  93:   decode to FMUL_D64_MM using decoder 152
                                             //  93:  }
  240, 3, 7,                                 //  98:  case 0x1f0: {
  OPC_CheckPredicate, 21,                    // 101:   check predicate 21
  OPC_Decode, 129, 13, 152, 1,               // 103:   decode to FDIV_D64_MM using decoder 152
                                             // 103:  }
  187, 4, 30,                                // 108:  case 0x23b: {
  OPC_SwitchField, 11, 5,                    // 111:   switch Inst[15:11] {
  8, 7,                                      // 114:   case 0x8: {
  OPC_CheckPredicate, 21,                    // 116:    check predicate 21
  OPC_Decode, 163, 19, 129, 1,               // 118:    decode to RSQRT_D64_MM using decoder 129
                                             // 118:   }
  9, 7,                                      // 123:   case 0x9: {
  OPC_CheckPredicate, 21,                    // 125:    check predicate 21
  OPC_Decode, 227, 13, 129, 1,               // 127:    decode to FSQRT_D64_MM using decoder 129
                                             // 127:   }
  10, 0,                                     // 132:   case 0xa: {
  OPC_CheckPredicate, 21,                    // 134:    check predicate 21
  OPC_Decode, 130, 19, 129, 1,               // 136:    decode to RECIP_D64_MM using decoder 129
                                             // 136:   }
                                             // 136:   } // switch Inst[15:11]
                                             // 136:  }
  251, 6, 0,                                 // 141:  case 0x37b: {
  OPC_SwitchField, 11, 5,                    // 144:   switch Inst[15:11] {
  2, 7,                                      // 147:   case 0x2: {
  OPC_CheckPredicate, 21,                    // 149:    check predicate 21
  OPC_Decode, 153, 10, 128, 1,               // 151:    decode to CVT_D64_S_MM using decoder 128
                                             // 151:   }
  3, 7,                                      // 156:   case 0x3: {
  OPC_CheckPredicate, 21,                    // 158:    check predicate 21
  OPC_Decode, 169, 10, 153, 1,               // 160:    decode to CVT_S_D64_MM using decoder 153
                                             // 160:   }
  4, 7,                                      // 165:   case 0x4: {
  OPC_CheckPredicate, 21,                    // 167:    check predicate 21
  OPC_Decode, 211, 12, 129, 1,               // 169:    decode to FABS_D64_MM using decoder 129
                                             // 169:   }
  5, 7,                                      // 174:   case 0x5: {
  OPC_CheckPredicate, 21,                    // 176:    check predicate 21
  OPC_Decode, 200, 13, 129, 1,               // 178:    decode to FNEG_D64_MM using decoder 129
                                             // 178:   }
  6, 0,                                      // 183:   case 0x6: {
  OPC_CheckPredicate, 21,                    // 185:    check predicate 21
  OPC_Decode, 155, 10, 128, 1,               // 187:    decode to CVT_D64_W_MM using decoder 128
                                             // 187:   }
                                             // 187:   } // switch Inst[15:11]
                                             // 187:  }
                                             // 187:  } // switch Inst[10:0]
                                             // 187: }
  46, 7,                                     // 192: case 0x2e: {
  OPC_CheckPredicate, 24,                    // 194:  check predicate 24
  OPC_Decode, 205, 19, 146, 1,               // 196:  decode to SDC1_D64_MMR6 using decoder 146
                                             // 196: }
  47, 0,                                     // 201: case 0x2f: {
  OPC_CheckPredicate, 24,                    // 203:  check predicate 24
  OPC_Decode, 240, 14, 146, 1,               // 205:  decode to LDC1_D64_MMR6 using decoder 146
                                             // 205: }
                                             // 205: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMicroMipsR632[1966] = {
  OPC_SwitchField, 26, 6,                    //    0: switch Inst[31:26] {
  0, 146, 5,                                 //    3: case 0x0: {
  OPC_SwitchField, 0, 6,                     //    6:  switch Inst[5:0] {
  0, 69,                                     //    9:  case 0x0: {
  OPC_SwitchField, 6, 5,                     //   11:   switch Inst[10:6] {
  0, 35,                                     //   14:   case 0x0: {
  OPC_Scope, 27,                             //   16:    try {
  OPC_SwitchField, 11, 15,                   //   18:     switch Inst[25:11] {
  1, 6,                                      //   21:     case 0x1: {
  OPC_CheckPredicate, 3,                     //   23:      check predicate 3
  OPC_Decode, 140, 21, 10,                   //   25:      decode to SSNOP_MMR6 using decoder 10
                                             //   25:     }
  3, 6,                                      //   29:     case 0x3: {
  OPC_CheckPredicate, 3,                     //   31:      check predicate 3
  OPC_Decode, 166, 12, 10,                   //   33:      decode to EHB_MMR6 using decoder 10
                                             //   33:     }
  5, 0,                                      //   37:     case 0x5: {
  OPC_CheckPredicate, 3,                     //   39:      check predicate 3
  OPC_Decode, 181, 18, 10,                   //   41:      decode to PAUSE_MMR6 using decoder 10
                                             //   41:     }
                                             //   41:     } // switch Inst[25:11]
                                             //   41:    } else try {
  OPC_CheckPredicate, 3,                     //   45:     check predicate 3
  OPC_Decode, 200, 20, 58,                   //   47:     decode to SLL_MMR6 using decoder 58
                                             //   47:    }
                                             //   47:   }
  5, 6,                                      //   51:   case 0x5: {
  OPC_CheckPredicate, 3,                     //   53:    check predicate 3
  OPC_Decode, 228, 19, 61,                   //   55:    decode to SELEQZ_MMR6 using decoder 61
                                             //   55:   }
  6, 6,                                      //   59:   case 0x6: {
  OPC_CheckPredicate, 3,                     //   61:    check predicate 3
  OPC_Decode, 235, 19, 61,                   //   63:    decode to SELNEZ_MMR6 using decoder 61
                                             //   63:   }
  7, 0,                                      //   67:   case 0x7: {
  OPC_CheckPredicate, 3,                     //   69:    check predicate 3
  OPC_CheckField, 14, 2, 0,                  //   71:    check Inst[15:14] == 0x0
  OPC_Decode, 253, 18, 154, 1,               //   75:    decode to RDHWR_MMR6 using decoder 154
                                             //   75:   }
                                             //   75:   } // switch Inst[10:6]
                                             //   75:  }
  7, 6,                                      //   80:  case 0x7: {
  OPC_CheckPredicate, 3,                     //   82:   check predicate 3
  OPC_Decode, 192, 8, 62,                    //   84:   decode to BREAK_MMR6 using decoder 62
                                             //   84:  }
  12, 6,                                     //   88:  case 0xc: {
  OPC_CheckPredicate, 3,                     //   90:   check predicate 3
  OPC_Decode, 179, 14, 63,                   //   92:   decode to INS_MMR6 using decoder 63
                                             //   92:  }
  15, 11,                                    //   96:  case 0xf: {
  OPC_CheckPredicate, 3,                     //   98:   check predicate 3
  OPC_CheckField, 6, 3, 0,                   //  100:   check Inst[8:6] == 0x0
  OPC_Decode, 161, 15, 155, 1,               //  104:   decode to LSA_MMR6 using decoder 155
                                             //  104:  }
  16, 79,                                    //  109:  case 0x10: {
  OPC_SwitchField, 6, 5,                     //  111:   switch Inst[10:6] {
  1, 10,                                     //  114:   case 0x1: {
  OPC_CheckPredicate, 3,                     //  116:    check predicate 3
  OPC_CheckField, 16, 5, 0,                  //  118:    check Inst[20:16] == 0x0
  OPC_Decode, 166, 9, 52,                    //  122:    decode to CLZ_MMR6 using decoder 52
                                             //  122:   }
  4, 6,                                      //  126:   case 0x4: {
  OPC_CheckPredicate, 3,                     //  128:    check predicate 3
  OPC_Decode, 214, 6, 61,                    //  130:    decode to ADD_MMR6 using decoder 61
                                             //  130:   }
  5, 6,                                      //  134:   case 0x5: {
  OPC_CheckPredicate, 3,                     //  136:    check predicate 3
  OPC_Decode, 190, 6, 61,                    //  138:    decode to ADDU_MMR6 using decoder 61
                                             //  138:   }
  6, 6,                                      //  142:   case 0x6: {
  OPC_CheckPredicate, 3,                     //  144:    check predicate 3
  OPC_Decode, 200, 21, 61,                   //  146:    decode to SUB_MMR6 using decoder 61
                                             //  146:   }
  7, 6,                                      //  150:   case 0x7: {
  OPC_CheckPredicate, 3,                     //  152:    check predicate 3
  OPC_Decode, 182, 21, 61,                   //  154:    decode to SUBU_MMR6 using decoder 61
                                             //  154:   }
  9, 6,                                      //  158:   case 0x9: {
  OPC_CheckPredicate, 3,                     //  160:    check predicate 3
  OPC_Decode, 234, 6, 61,                    //  162:    decode to AND_MMR6 using decoder 61
                                             //  162:   }
  10, 6,                                     //  166:   case 0xa: {
  OPC_CheckPredicate, 3,                     //  168:    check predicate 3
  OPC_Decode, 171, 18, 61,                   //  170:    decode to OR_MMR6 using decoder 61
                                             //  170:   }
  11, 6,                                     //  174:   case 0xb: {
  OPC_CheckPredicate, 3,                     //  176:    check predicate 3
  OPC_Decode, 158, 18, 61,                   //  178:    decode to NOR_MMR6 using decoder 61
                                             //  178:   }
  12, 0,                                     //  182:   case 0xc: {
  OPC_CheckPredicate, 3,                     //  184:    check predicate 3
  OPC_Decode, 225, 22, 61,                   //  186:    decode to XOR_MMR6 using decoder 61
                                             //  186:   }
                                             //  186:   } // switch Inst[10:6]
                                             //  186:  }
  24, 67,                                    //  190:  case 0x18: {
  OPC_SwitchField, 6, 5,                     //  192:   switch Inst[10:6] {
  0, 6,                                      //  195:   case 0x0: {
  OPC_CheckPredicate, 3,                     //  197:    check predicate 3
  OPC_Decode, 251, 17, 61,                   //  199:    decode to MUL_MMR6 using decoder 61
                                             //  199:   }
  1, 6,                                      //  203:   case 0x1: {
  OPC_CheckPredicate, 3,                     //  205:    check predicate 3
  OPC_Decode, 211, 17, 61,                   //  207:    decode to MUH_MMR6 using decoder 61
                                             //  207:   }
  2, 6,                                      //  211:   case 0x2: {
  OPC_CheckPredicate, 3,                     //  213:    check predicate 3
  OPC_Decode, 245, 17, 61,                   //  215:    decode to MULU_MMR6 using decoder 61
                                             //  215:   }
  3, 6,                                      //  219:   case 0x3: {
  OPC_CheckPredicate, 3,                     //  221:    check predicate 3
  OPC_Decode, 210, 17, 61,                   //  223:    decode to MUHU_MMR6 using decoder 61
                                             //  223:   }
  4, 6,                                      //  227:   case 0x4: {
  OPC_CheckPredicate, 3,                     //  229:    check predicate 3
  OPC_Decode, 184, 11, 61,                   //  231:    decode to DIV_MMR6 using decoder 61
                                             //  231:   }
  5, 6,                                      //  235:   case 0x5: {
  OPC_CheckPredicate, 3,                     //  237:    check predicate 3
  OPC_Decode, 219, 16, 61,                   //  239:    decode to MOD_MMR6 using decoder 61
                                             //  239:   }
  6, 6,                                      //  243:   case 0x6: {
  OPC_CheckPredicate, 3,                     //  245:    check predicate 3
  OPC_Decode, 183, 11, 61,                   //  247:    decode to DIVU_MMR6 using decoder 61
                                             //  247:   }
  7, 0,                                      //  251:   case 0x7: {
  OPC_CheckPredicate, 3,                     //  253:    check predicate 3
  OPC_Decode, 218, 16, 61,                   //  255:    decode to MODU_MMR6 using decoder 61
                                             //  255:   }
                                             //  255:   } // switch Inst[10:6]
                                             //  255:  }
  31, 11,                                    //  259:  case 0x1f: {
  OPC_CheckPredicate, 3,                     //  261:   check predicate 3
  OPC_CheckField, 6, 3, 0,                   //  263:   check Inst[8:6] == 0x0
  OPC_Decode, 222, 6, 156, 1,                //  267:   decode to ALIGN_MMR6 using decoder 156
                                             //  267:  }
  44, 6,                                     //  272:  case 0x2c: {
  OPC_CheckPredicate, 3,                     //  274:   check predicate 3
  OPC_Decode, 207, 12, 72,                   //  276:   decode to EXT_MMR6 using decoder 72
                                             //  276:  }
  52, 27,                                    //  280:  case 0x34: {
  OPC_SwitchField, 6, 5,                     //  282:   switch Inst[10:6] {
  3, 10,                                     //  285:   case 0x3: {
  OPC_CheckPredicate, 3,                     //  287:    check predicate 3
  OPC_CheckField, 14, 2, 0,                  //  289:    check Inst[15:14] == 0x0
  OPC_Decode, 165, 16, 74,                   //  293:    decode to MFHC0_MMR6 using decoder 74
                                             //  293:   }
  11, 0,                                     //  297:   case 0xb: {
  OPC_CheckPredicate, 3,                     //  299:    check predicate 3
  OPC_CheckField, 14, 2, 0,                  //  301:    check Inst[15:14] == 0x0
  OPC_Decode, 181, 17, 75,                   //  305:    decode to MTHC0_MMR6 using decoder 75
                                             //  305:   }
                                             //  305:   } // switch Inst[10:6]
                                             //  305:  }
  60, 211, 2,                                //  309:  case 0x3c: {
  OPC_SwitchField, 14, 2,                    //  312:   switch Inst[15:14] {
  0, 81,                                     //  315:   case 0x0: {
  OPC_SwitchField, 6, 5,                     //  317:    switch Inst[10:6] {
  3, 6,                                      //  320:    case 0x3: {
  OPC_CheckPredicate, 3,                     //  322:     check predicate 3
  OPC_Decode, 156, 16, 74,                   //  324:     decode to MFC0_MMR6 using decoder 74
                                             //  324:    }
  5, 27,                                     //  328:    case 0x5: {
  OPC_SwitchField, 11, 3,                    //  330:     switch Inst[13:11] {
  3, 10,                                     //  333:     case 0x3: {
  OPC_CheckPredicate, 3,                     //  335:      check predicate 3
  OPC_CheckField, 21, 5, 0,                  //  337:      check Inst[25:21] == 0x0
  OPC_Decode, 161, 12, 99,                   //  341:      decode to DVP_MMR6 using decoder 99
                                             //  341:     }
  7, 0,                                      //  345:     case 0x7: {
  OPC_CheckPredicate, 3,                     //  347:      check predicate 3
  OPC_CheckField, 21, 5, 0,                  //  349:      check Inst[25:21] == 0x0
  OPC_Decode, 178, 12, 99,                   //  353:      decode to EVP_MMR6 using decoder 99
                                             //  353:     }
                                             //  353:     } // switch Inst[13:11]
                                             //  353:    }
  11, 6,                                     //  357:    case 0xb: {
  OPC_CheckPredicate, 3,                     //  359:     check predicate 3
  OPC_Decode, 171, 17, 75,                   //  361:     decode to MTC0_MMR6 using decoder 75
                                             //  361:    }
  12, 10,                                    //  365:    case 0xc: {
  OPC_CheckPredicate, 3,                     //  367:     check predicate 3
  OPC_CheckField, 11, 3, 1,                  //  369:     check Inst[13:11] == 0x1
  OPC_Decode, 248, 7, 93,                    //  373:     decode to BITSWAP_MMR6 using decoder 93
                                             //  373:    }
  28, 0,                                     //  377:    case 0x1c: {
  OPC_SwitchField, 11, 3,                    //  379:     switch Inst[13:11] {
  1, 6,                                      //  382:     case 0x1: {
  OPC_CheckPredicate, 3,                     //  384:      check predicate 3
  OPC_Decode, 187, 14, 86,                   //  386:      decode to JALRC_MMR6 using decoder 86
                                             //  386:     }
  3, 0,                                      //  390:     case 0x3: {
  OPC_CheckPredicate, 3,                     //  392:      check predicate 3
  OPC_Decode, 186, 14, 86,                   //  394:      decode to JALRC_HB_MMR6 using decoder 86
                                             //  394:     }
                                             //  394:     } // switch Inst[13:11]
                                             //  394:    }
                                             //  394:    } // switch Inst[10:6]
                                             //  394:   }
  1, 155, 1,                                 //  398:   case 0x1: {
  OPC_SwitchField, 11, 3,                    //  401:    switch Inst[13:11] {
  0, 27,                                     //  404:    case 0x0: {
  OPC_SwitchField, 6, 5,                     //  406:     switch Inst[10:6] {
  13, 10,                                    //  409:     case 0xd: {
  OPC_CheckPredicate, 3,                     //  411:      check predicate 3
  OPC_CheckField, 16, 10, 0,                 //  413:      check Inst[25:16] == 0x0
  OPC_Decode, 168, 22, 10,                   //  417:      decode to TLBINV_MMR6 using decoder 10
                                             //  417:     }
  29, 0,                                     //  421:     case 0x1d: {
  OPC_CheckPredicate, 3,                     //  423:      check predicate 3
  OPC_CheckField, 21, 5, 0,                  //  425:      check Inst[25:21] == 0x0
  OPC_Decode, 194, 11, 99,                   //  429:      decode to DI_MMR6 using decoder 99
                                             //  429:     }
                                             //  429:     } // switch Inst[10:6]
                                             //  429:    }
  1, 19,                                     //  433:    case 0x1: {
  OPC_SwitchField, 6, 5,                     //  435:     switch Inst[10:6] {
  12, 6,                                     //  438:     case 0xc: {
  OPC_CheckPredicate, 3,                     //  440:      check predicate 3
  OPC_Decode, 146, 9, 86,                    //  442:      decode to CLO_MMR6 using decoder 86
                                             //  442:     }
  20, 0,                                     //  446:     case 0x14: {
  OPC_CheckPredicate, 3,                     //  448:      check predicate 3
  OPC_Decode, 162, 16, 97,                   //  450:      decode to MFC2_MMR6 using decoder 97
                                             //  450:     }
                                             //  450:     } // switch Inst[10:6]
                                             //  450:    }
  2, 27,                                     //  454:    case 0x2: {
  OPC_SwitchField, 6, 5,                     //  456:     switch Inst[10:6] {
  13, 10,                                    //  459:     case 0xd: {
  OPC_CheckPredicate, 3,                     //  461:      check predicate 3
  OPC_CheckField, 16, 10, 0,                 //  463:      check Inst[25:16] == 0x0
  OPC_Decode, 167, 22, 10,                   //  467:      decode to TLBINVF_MMR6 using decoder 10
                                             //  467:     }
  29, 0,                                     //  471:     case 0x1d: {
  OPC_CheckPredicate, 3,                     //  473:      check predicate 3
  OPC_CheckField, 21, 5, 0,                  //  475:      check Inst[25:21] == 0x0
  OPC_Decode, 169, 12, 99,                   //  479:      decode to EI_MMR6 using decoder 99
                                             //  479:     }
                                             //  479:     } // switch Inst[10:6]
                                             //  479:    }
  3, 10,                                     //  483:    case 0x3: {
  OPC_CheckPredicate, 3,                     //  485:     check predicate 3
  OPC_CheckField, 6, 5, 20,                  //  487:     check Inst[10:6] == 0x14
  OPC_Decode, 178, 17, 98,                   //  491:     decode to MTC2_MMR6 using decoder 98
                                             //  491:    }
  4, 14,                                     //  495:    case 0x4: {
  OPC_CheckPredicate, 25,                    //  497:     check predicate 25
  OPC_CheckField, 21, 5, 0,                  //  499:     check Inst[25:21] == 0x0
  OPC_CheckField, 6, 5, 5,                   //  503:     check Inst[10:6] == 0x5
  OPC_Decode, 134, 14, 99,                   //  507:     decode to GINVI_MMR6 using decoder 99
                                             //  507:    }
  5, 14,                                     //  511:    case 0x5: {
  OPC_CheckPredicate, 3,                     //  513:     check predicate 3
  OPC_CheckField, 21, 5, 0,                  //  515:     check Inst[25:21] == 0x0
  OPC_CheckField, 6, 5, 13,                  //  519:     check Inst[10:6] == 0xd
  OPC_Decode, 245, 21, 94,                   //  523:     decode to SYNC_MMR6 using decoder 94
                                             //  523:    }
  6, 15,                                     //  527:    case 0x6: {
  OPC_CheckPredicate, 25,                    //  529:     check predicate 25
  OPC_CheckField, 21, 5, 0,                  //  531:     check Inst[25:21] == 0x0
  OPC_CheckField, 6, 3, 5,                   //  535:     check Inst[8:6] == 0x5
  OPC_Decode, 136, 14, 157, 1,               //  539:     decode to GINVT_MMR6 using decoder 157
                                             //  539:    }
  7, 0,                                      //  544:    case 0x7: {
  OPC_CheckPredicate, 3,                     //  546:     check predicate 3
  OPC_CheckField, 6, 5, 12,                  //  548:     check Inst[10:6] == 0xc
  OPC_Decode, 217, 22, 86,                   //  552:     decode to WSBH_MMR6 using decoder 86
                                             //  552:    }
                                             //  552:    } // switch Inst[13:11]
                                             //  552:   }
  2, 27,                                     //  556:   case 0x2: {
  OPC_SwitchField, 6, 8,                     //  558:    switch Inst[13:6] {
  52, 6,                                     //  561:    case 0x34: {
  OPC_CheckPredicate, 3,                     //  563:     check predicate 3
  OPC_Decode, 170, 16, 97,                   //  565:     decode to MFHC2_MMR6 using decoder 97
                                             //  565:    }
  77, 6,                                     //  569:    case 0x4d: {
  OPC_CheckPredicate, 3,                     //  571:     check predicate 3
  OPC_Decode, 211, 22, 95,                   //  573:     decode to WAIT_MMR6 using decoder 95
                                             //  573:    }
  116, 0,                                    //  577:    case 0x74: {
  OPC_CheckPredicate, 3,                     //  579:     check predicate 3
  OPC_Decode, 186, 17, 98,                   //  581:     decode to MTHC2_MMR6 using decoder 98
                                             //  581:    }
                                             //  581:    } // switch Inst[13:6]
                                             //  581:   }
  3, 0,                                      //  585:   case 0x3: {
  OPC_SwitchField, 6, 8,                     //  587:    switch Inst[13:6] {
  109, 6,                                    //  590:    case 0x6d: {
  OPC_CheckPredicate, 3,                     //  592:     check predicate 3
  OPC_Decode, 201, 19, 95,                   //  594:     decode to SDBBP_MMR6 using decoder 95
                                             //  594:    }
  133, 1, 6,                                 //  598:    case 0x85: {
  OPC_CheckPredicate, 3,                     //  601:     check predicate 3
  OPC_Decode, 254, 18, 86,                   //  603:     decode to RDPGPR_MMR6 using decoder 86
                                             //  603:    }
  141, 1, 10,                                //  607:    case 0x8d: {
  OPC_CheckPredicate, 3,                     //  610:     check predicate 3
  OPC_CheckField, 16, 10, 0,                 //  612:     check Inst[25:16] == 0x0
  OPC_Decode, 172, 11, 10,                   //  616:     decode to DERET_MMR6 using decoder 10
                                             //  616:    }
  197, 1, 6,                                 //  620:    case 0xc5: {
  OPC_CheckPredicate, 3,                     //  623:     check predicate 3
  OPC_Decode, 214, 22, 86,                   //  625:     decode to WRPGPR_MMR6 using decoder 86
                                             //  625:    }
  205, 1, 0,                                 //  629:    case 0xcd: {
  OPC_SwitchField, 16, 10,                   //  632:     switch Inst[25:16] {
  0, 6,                                      //  635:     case 0x0: {
  OPC_CheckPredicate, 3,                     //  637:      check predicate 3
  OPC_Decode, 175, 12, 10,                   //  639:      decode to ERET_MMR6 using decoder 10
                                             //  639:     }
  1, 0,                                      //  643:     case 0x1: {
  OPC_CheckPredicate, 3,                     //  645:      check predicate 3
  OPC_Decode, 173, 12, 10,                   //  647:      decode to ERETNC_MMR6 using decoder 10
                                             //  647:     }
                                             //  647:     } // switch Inst[25:16]
                                             //  647:    }
                                             //  647:    } // switch Inst[13:6]
                                             //  647:   }
                                             //  647:   } // switch Inst[15:14]
                                             //  647:  }
  63, 0,                                     //  651:  case 0x3f: {
  OPC_CheckPredicate, 3,                     //  653:   check predicate 3
  OPC_CheckField, 22, 4, 0,                  //  655:   check Inst[25:22] == 0x0
  OPC_Decode, 176, 20, 158, 1,               //  659:   decode to SIGRIE_MMR6 using decoder 158
                                             //  659:  }
                                             //  659:  } // switch Inst[5:0]
                                             //  659: }
  4, 19,                                     //  664: case 0x4: {
  OPC_Scope, 11,                             //  666:  try {
  OPC_CheckField, 16, 5, 0,                  //  668:   check Inst[20:16] == 0x0
  OPC_CheckPredicate, 3,                     //  672:   check predicate 3
  OPC_Decode, 163, 15, 159, 1,               //  674:   decode to LUI_MMR6 using decoder 159
                                             //  674:  } else try {
  OPC_CheckPredicate, 3,                     //  679:   check predicate 3
  OPC_Decode, 252, 6, 115,                   //  681:   decode to AUI_MMR6 using decoder 115
                                             //  681:  }
                                             //  681: }
  5, 7,                                      //  685: case 0x5: {
  OPC_CheckPredicate, 3,                     //  687:  check predicate 3
  OPC_Decode, 229, 14, 160, 1,               //  689:  decode to LBU_MMR6 using decoder 160
                                             //  689: }
  6, 6,                                      //  694: case 0x6: {
  OPC_CheckPredicate, 3,                     //  696:  check predicate 3
  OPC_Decode, 185, 19, 105,                  //  698:  decode to SB_MMR6 using decoder 105
                                             //  698: }
  7, 7,                                      //  702: case 0x7: {
  OPC_CheckPredicate, 3,                     //  704:  check predicate 3
  OPC_Decode, 231, 14, 160, 1,               //  706:  decode to LB_MMR6 using decoder 160
                                             //  706: }
  8, 63,                                     //  711: case 0x8: {
  OPC_SwitchField, 12, 4,                    //  713:  switch Inst[15:12] {
  0, 11,                                     //  716:  case 0x0: {
  OPC_CheckPredicate, 3,                     //  718:   check predicate 3
  OPC_CheckField, 11, 1, 0,                  //  720:   check Inst[11] == 0x0
  OPC_Decode, 176, 15, 161, 1,               //  724:   decode to LWC2_MMR6 using decoder 161
                                             //  724:  }
  2, 11,                                     //  729:  case 0x2: {
  OPC_CheckPredicate, 3,                     //  731:   check predicate 3
  OPC_CheckField, 11, 1, 0,                  //  733:   check Inst[11] == 0x0
  OPC_Decode, 244, 14, 161, 1,               //  737:   decode to LDC2_MMR6 using decoder 161
                                             //  737:  }
  6, 6,                                      //  742:  case 0x6: {
  OPC_CheckPredicate, 3,                     //  744:   check predicate 3
  OPC_Decode, 223, 8, 107,                   //  746:   decode to CACHE_MMR6 using decoder 107
                                             //  746:  }
  8, 11,                                     //  750:  case 0x8: {
  OPC_CheckPredicate, 3,                     //  752:   check predicate 3
  OPC_CheckField, 11, 1, 0,                  //  754:   check Inst[11] == 0x0
  OPC_Decode, 213, 21, 161, 1,               //  758:   decode to SWC2_MMR6 using decoder 161
                                             //  758:  }
  10, 0,                                     //  763:  case 0xa: {
  OPC_CheckPredicate, 3,                     //  765:   check predicate 3
  OPC_CheckField, 11, 1, 0,                  //  767:   check Inst[11] == 0x0
  OPC_Decode, 209, 19, 161, 1,               //  771:   decode to SDC2_MMR6 using decoder 161
                                             //  771:  }
                                             //  771:  } // switch Inst[15:12]
                                             //  771: }
  12, 6,                                     //  776: case 0xc: {
  OPC_CheckPredicate, 3,                     //  778:  check predicate 3
  OPC_Decode, 154, 6, 104,                   //  780:  decode to ADDIU_MMR6 using decoder 104
                                             //  780: }
  14, 6,                                     //  784: case 0xe: {
  OPC_CheckPredicate, 3,                     //  786:  check predicate 3
  OPC_Decode, 174, 20, 105,                  //  788:  decode to SH_MMR6 using decoder 105
                                             //  788: }
  16, 48,                                    //  792: case 0x10: {
  OPC_SwitchField, 21, 5,                    //  794:  switch Inst[25:21] {
  8, 7,                                      //  797:  case 0x8: {
  OPC_CheckPredicate, 26,                    //  799:   check predicate 26
  OPC_Decode, 164, 7, 162, 1,                //  801:   decode to BC1EQZC_MMR6 using decoder 162
                                             //  801:  }
  9, 7,                                      //  806:  case 0x9: {
  OPC_CheckPredicate, 26,                    //  808:   check predicate 26
  OPC_Decode, 169, 7, 162, 1,                //  810:   decode to BC1NEZC_MMR6 using decoder 162
                                             //  810:  }
  10, 7,                                     //  815:  case 0xa: {
  OPC_CheckPredicate, 3,                     //  817:   check predicate 3
  OPC_Decode, 174, 7, 163, 1,                //  819:   decode to BC2EQZC_MMR6 using decoder 163
                                             //  819:  }
  11, 7,                                     //  824:  case 0xb: {
  OPC_CheckPredicate, 3,                     //  826:   check predicate 3
  OPC_Decode, 176, 7, 163, 1,                //  828:   decode to BC2NEZC_MMR6 using decoder 163
                                             //  828:  }
  12, 0,                                     //  833:  case 0xc: {
  OPC_CheckPredicate, 3,                     //  835:   check predicate 3
  OPC_Decode, 243, 21, 164, 1,               //  837:   decode to SYNCI_MMR6 using decoder 164
                                             //  837:  }
                                             //  837:  } // switch Inst[25:21]
                                             //  837: }
  20, 6,                                     //  842: case 0x14: {
  OPC_CheckPredicate, 3,                     //  844:  check predicate 3
  OPC_Decode, 169, 18, 115,                  //  846:  decode to ORI_MMR6 using decoder 115
                                             //  846: }
  21, 216, 6,                                //  850: case 0x15: {
  OPC_SwitchField, 0, 11,                    //  853:  switch Inst[10:0] {
  3, 7,                                      //  856:  case 0x3: {
  OPC_CheckPredicate, 26,                    //  858:   check predicate 26
  OPC_Decode, 208, 16, 165, 1,               //  860:   decode to MIN_S_MMR6 using decoder 165
                                             //  860:  }
  5, 7,                                      //  865:  case 0x5: {
  OPC_CheckPredicate, 26,                    //  867:   check predicate 26
  OPC_Decode, 187, 9, 166, 1,                //  869:   decode to CMP_AF_S_MMR6 using decoder 166
                                             //  869:  }
  11, 7,                                     //  874:  case 0xb: {
  OPC_CheckPredicate, 26,                    //  876:   check predicate 26
  OPC_Decode, 149, 16, 165, 1,               //  878:   decode to MAX_S_MMR6 using decoder 165
                                             //  878:  }
  21, 7,                                     //  883:  case 0x15: {
  OPC_CheckPredicate, 26,                    //  885:   check predicate 26
  OPC_Decode, 186, 9, 167, 1,                //  887:   decode to CMP_AF_D_MMR6 using decoder 167
                                             //  887:  }
  32, 11,                                    //  892:  case 0x20: {
  OPC_CheckPredicate, 3,                     //  894:   check predicate 3
  OPC_CheckField, 11, 5, 0,                  //  896:   check Inst[15:11] == 0x0
  OPC_Decode, 144, 19, 168, 1,               //  900:   decode to RINT_S_MMR6 using decoder 168
                                             //  900:  }
  35, 7,                                     //  905:  case 0x23: {
  OPC_CheckPredicate, 26,                    //  907:   check predicate 26
  OPC_Decode, 189, 16, 165, 1,               //  909:   decode to MINA_S_MMR6 using decoder 165
                                             //  909:  }
  43, 7,                                     //  914:  case 0x2b: {
  OPC_CheckPredicate, 26,                    //  916:   check predicate 26
  OPC_Decode, 130, 16, 165, 1,               //  918:   decode to MAXA_S_MMR6 using decoder 165
                                             //  918:  }
  48, 7,                                     //  923:  case 0x30: {
  OPC_CheckPredicate, 26,                    //  925:   check predicate 26
  OPC_Decode, 222, 12, 169, 1,               //  927:   decode to FADD_S_MMR6 using decoder 169
                                             //  927:  }
  56, 7,                                     //  932:  case 0x38: {
  OPC_CheckPredicate, 3,                     //  934:   check predicate 3
  OPC_Decode, 230, 19, 165, 1,               //  936:   decode to SELEQZ_S_MMR6 using decoder 165
                                             //  936:  }
  59, 20,                                    //  941:  case 0x3b: {
  OPC_SwitchField, 11, 5,                    //  943:   switch Inst[15:11] {
  4, 6,                                      //  946:   case 0x4: {
  OPC_CheckPredicate, 26,                    //  948:    check predicate 26
  OPC_Decode, 160, 16, 126,                  //  950:    decode to MFC1_MMR6 using decoder 126
                                             //  950:   }
  5, 0,                                      //  954:   case 0x5: {
  OPC_CheckPredicate, 26,                    //  956:    check predicate 26
  OPC_Decode, 176, 17, 132, 1,               //  958:    decode to MTC1_MMR6 using decoder 132
                                             //  958:   }
                                             //  958:   } // switch Inst[15:11]
                                             //  958:  }
  69, 7,                                     //  963:  case 0x45: {
  OPC_CheckPredicate, 26,                    //  965:   check predicate 26
  OPC_Decode, 255, 9, 166, 1,                //  967:   decode to CMP_UN_S_MMR6 using decoder 166
                                             //  967:  }
  85, 7,                                     //  972:  case 0x55: {
  OPC_CheckPredicate, 26,                    //  974:   check predicate 26
  OPC_Decode, 253, 9, 167, 1,                //  976:   decode to CMP_UN_D_MMR6 using decoder 167
                                             //  976:  }
  96, 11,                                    //  981:  case 0x60: {
  OPC_CheckPredicate, 3,                     //  983:   check predicate 3
  OPC_CheckField, 11, 5, 0,                  //  985:   check Inst[15:11] == 0x0
  OPC_Decode, 255, 8, 168, 1,                //  989:   decode to CLASS_S_MMR6 using decoder 168
                                             //  989:  }
  112, 7,                                    //  994:  case 0x70: {
  OPC_CheckPredicate, 26,                    //  996:   check predicate 26
  OPC_Decode, 239, 13, 169, 1,               //  998:   decode to FSUB_S_MMR6 using decoder 169
                                             //  998:  }
  120, 7,                                    // 1003:  case 0x78: {
  OPC_CheckPredicate, 3,                     // 1005:   check predicate 3
  OPC_Decode, 237, 19, 165, 1,               // 1007:   decode to SELNEZ_S_MMR6 using decoder 165
                                             // 1007:  }
  123, 21,                                   // 1012:  case 0x7b: {
  OPC_SwitchField, 11, 5,                    // 1014:   switch Inst[15:11] {
  0, 7,                                      // 1017:   case 0x0: {
  OPC_CheckPredicate, 26,                    // 1019:    check predicate 26
  OPC_Decode, 184, 13, 131, 1,               // 1021:    decode to FMOV_S_MMR6 using decoder 131
                                             // 1021:   }
  4, 0,                                      // 1026:   case 0x4: {
  OPC_CheckPredicate, 26,                    // 1028:    check predicate 26
  OPC_Decode, 181, 13, 129, 1,               // 1030:    decode to FMOV_D_MMR6 using decoder 129
                                             // 1030:   }
                                             // 1030:   } // switch Inst[15:11]
                                             // 1030:  }
  133, 1, 7,                                 // 1035:  case 0x85: {
  OPC_CheckPredicate, 26,                    // 1038:   check predicate 26
  OPC_Decode, 193, 9, 166, 1,                // 1040:   decode to CMP_EQ_S_MMR6 using decoder 166
                                             // 1040:  }
  149, 1, 7,                                 // 1045:  case 0x95: {
  OPC_CheckPredicate, 26,                    // 1048:   check predicate 26
  OPC_Decode, 189, 9, 167, 1,                // 1050:   decode to CMP_EQ_D_MMR6 using decoder 167
                                             // 1050:  }
  176, 1, 7,                                 // 1055:  case 0xb0: {
  OPC_CheckPredicate, 26,                    // 1058:   check predicate 26
  OPC_Decode, 195, 13, 169, 1,               // 1060:   decode to FMUL_S_MMR6 using decoder 169
                                             // 1060:  }
  184, 1, 7,                                 // 1065:  case 0xb8: {
  OPC_CheckPredicate, 3,                     // 1068:   check predicate 3
  OPC_Decode, 241, 19, 170, 1,               // 1070:   decode to SEL_S_MMR6 using decoder 170
                                             // 1070:  }
  197, 1, 7,                                 // 1075:  case 0xc5: {
  OPC_CheckPredicate, 26,                    // 1078:   check predicate 26
  OPC_Decode, 243, 9, 166, 1,                // 1080:   decode to CMP_UEQ_S_MMR6 using decoder 166
                                             // 1080:  }
  213, 1, 7,                                 // 1085:  case 0xd5: {
  OPC_CheckPredicate, 26,                    // 1088:   check predicate 26
  OPC_Decode, 241, 9, 167, 1,                // 1090:   decode to CMP_UEQ_D_MMR6 using decoder 167
                                             // 1090:  }
  240, 1, 7,                                 // 1095:  case 0xf0: {
  OPC_CheckPredicate, 26,                    // 1098:   check predicate 26
  OPC_Decode, 132, 13, 169, 1,               // 1100:   decode to FDIV_S_MMR6 using decoder 169
                                             // 1100:  }
  133, 2, 7,                                 // 1105:  case 0x105: {
  OPC_CheckPredicate, 26,                    // 1108:   check predicate 26
  OPC_Decode, 207, 9, 166, 1,                // 1110:   decode to CMP_LT_S_MMR6 using decoder 166
                                             // 1110:  }
  149, 2, 7,                                 // 1115:  case 0x115: {
  OPC_CheckPredicate, 26,                    // 1118:   check predicate 26
  OPC_Decode, 203, 9, 167, 1,                // 1120:   decode to CMP_LT_D_MMR6 using decoder 167
                                             // 1120:  }
  187, 2, 30,                                // 1125:  case 0x13b: {
  OPC_SwitchField, 11, 5,                    // 1128:   switch Inst[15:11] {
  0, 7,                                      // 1131:   case 0x0: {
  OPC_CheckPredicate, 26,                    // 1133:    check predicate 26
  OPC_Decode, 162, 10, 128, 1,               // 1135:    decode to CVT_L_S_MMR6 using decoder 128
                                             // 1135:   }
  1, 7,                                      // 1140:   case 0x1: {
  OPC_CheckPredicate, 26,                    // 1142:    check predicate 26
  OPC_Decode, 183, 10, 131, 1,               // 1144:    decode to CVT_W_S_MMR6 using decoder 131
                                             // 1144:   }
  8, 0,                                      // 1149:   case 0x8: {
  OPC_CheckPredicate, 26,                    // 1151:    check predicate 26
  OPC_Decode, 159, 10, 129, 1,               // 1153:    decode to CVT_L_D_MMR6 using decoder 129
                                             // 1153:   }
                                             // 1153:   } // switch Inst[15:11]
                                             // 1153:  }
  197, 2, 7,                                 // 1158:  case 0x145: {
  OPC_CheckPredicate, 26,                    // 1161:   check predicate 26
  OPC_Decode, 251, 9, 166, 1,                // 1163:   decode to CMP_ULT_S_MMR6 using decoder 166
                                             // 1163:  }
  213, 2, 7,                                 // 1168:  case 0x155: {
  OPC_CheckPredicate, 26,                    // 1171:   check predicate 26
  OPC_Decode, 249, 9, 167, 1,                // 1173:   decode to CMP_ULT_D_MMR6 using decoder 167
                                             // 1173:  }
  133, 3, 7,                                 // 1178:  case 0x185: {
  OPC_CheckPredicate, 26,                    // 1181:   check predicate 26
  OPC_Decode, 201, 9, 166, 1,                // 1183:   decode to CMP_LE_S_MMR6 using decoder 166
                                             // 1183:  }
  149, 3, 7,                                 // 1188:  case 0x195: {
  OPC_CheckPredicate, 26,                    // 1191:   check predicate 26
  OPC_Decode, 197, 9, 167, 1,                // 1193:   decode to CMP_LE_D_MMR6 using decoder 167
                                             // 1193:  }
  184, 3, 7,                                 // 1198:  case 0x1b8: {
  OPC_CheckPredicate, 26,                    // 1201:   check predicate 26
  OPC_Decode, 226, 15, 171, 1,               // 1203:   decode to MADDF_S_MMR6 using decoder 171
                                             // 1203:  }
  197, 3, 7,                                 // 1208:  case 0x1c5: {
  OPC_CheckPredicate, 26,                    // 1211:   check predicate 26
  OPC_Decode, 247, 9, 166, 1,                // 1213:   decode to CMP_ULE_S_MMR6 using decoder 166
                                             // 1213:  }
  213, 3, 7,                                 // 1218:  case 0x1d5: {
  OPC_CheckPredicate, 26,                    // 1221:   check predicate 26
  OPC_Decode, 245, 9, 167, 1,                // 1223:   decode to CMP_ULE_D_MMR6 using decoder 167
                                             // 1223:  }
  248, 3, 7,                                 // 1228:  case 0x1f8: {
  OPC_CheckPredicate, 26,                    // 1231:   check predicate 26
  OPC_Decode, 149, 17, 171, 1,               // 1233:   decode to MSUBF_S_MMR6 using decoder 171
                                             // 1233:  }
  131, 4, 7,                                 // 1238:  case 0x203: {
  OPC_CheckPredicate, 26,                    // 1241:   check predicate 26
  OPC_Decode, 203, 16, 152, 1,               // 1243:   decode to MIN_D_MMR6 using decoder 152
                                             // 1243:  }
  133, 4, 7,                                 // 1248:  case 0x205: {
  OPC_CheckPredicate, 26,                    // 1251:   check predicate 26
  OPC_Decode, 211, 9, 166, 1,                // 1253:   decode to CMP_SAF_S_MMR6 using decoder 166
                                             // 1253:  }
  139, 4, 7,                                 // 1258:  case 0x20b: {
  OPC_CheckPredicate, 26,                    // 1261:   check predicate 26
  OPC_Decode, 144, 16, 152, 1,               // 1263:   decode to MAX_D_MMR6 using decoder 152
                                             // 1263:  }
  149, 4, 7,                                 // 1268:  case 0x215: {
  OPC_CheckPredicate, 26,                    // 1271:   check predicate 26
  OPC_Decode, 209, 9, 167, 1,                // 1273:   decode to CMP_SAF_D_MMR6 using decoder 167
                                             // 1273:  }
  160, 4, 11,                                // 1278:  case 0x220: {
  OPC_CheckPredicate, 3,                     // 1281:   check predicate 3
  OPC_CheckField, 11, 5, 0,                  // 1283:   check Inst[15:11] == 0x0
  OPC_Decode, 142, 19, 172, 1,               // 1287:   decode to RINT_D_MMR6 using decoder 172
                                             // 1287:  }
  163, 4, 7,                                 // 1292:  case 0x223: {
  OPC_CheckPredicate, 26,                    // 1295:   check predicate 26
  OPC_Decode, 187, 16, 152, 1,               // 1297:   decode to MINA_D_MMR6 using decoder 152
                                             // 1297:  }
  171, 4, 7,                                 // 1302:  case 0x22b: {
  OPC_CheckPredicate, 26,                    // 1305:   check predicate 26
  OPC_Decode, 128, 16, 152, 1,               // 1307:   decode to MAXA_D_MMR6 using decoder 152
                                             // 1307:  }
  184, 4, 7,                                 // 1312:  case 0x238: {
  OPC_CheckPredicate, 3,                     // 1315:   check predicate 3
  OPC_Decode, 227, 19, 152, 1,               // 1317:   decode to SELEQZ_D_MMR6 using decoder 152
                                             // 1317:  }
  197, 4, 7,                                 // 1322:  case 0x245: {
  OPC_CheckPredicate, 26,                    // 1325:   check predicate 26
  OPC_Decode, 239, 9, 166, 1,                // 1327:   decode to CMP_SUN_S_MMR6 using decoder 166
                                             // 1327:  }
  213, 4, 7,                                 // 1332:  case 0x255: {
  OPC_CheckPredicate, 26,                    // 1335:   check predicate 26
  OPC_Decode, 237, 9, 167, 1,                // 1337:   decode to CMP_SUN_D_MMR6 using decoder 167
                                             // 1337:  }
  224, 4, 11,                                // 1342:  case 0x260: {
  OPC_CheckPredicate, 3,                     // 1345:   check predicate 3
  OPC_CheckField, 11, 5, 0,                  // 1347:   check Inst[15:11] == 0x0
  OPC_Decode, 253, 8, 172, 1,                // 1351:   decode to CLASS_D_MMR6 using decoder 172
                                             // 1351:  }
  248, 4, 7,                                 // 1356:  case 0x278: {
  OPC_CheckPredicate, 3,                     // 1359:   check predicate 3
  OPC_Decode, 234, 19, 152, 1,               // 1361:   decode to SELNEZ_D_MMR6 using decoder 152
                                             // 1361:  }
  133, 5, 7,                                 // 1366:  case 0x285: {
  OPC_CheckPredicate, 26,                    // 1369:   check predicate 26
  OPC_Decode, 215, 9, 166, 1,                // 1371:   decode to CMP_SEQ_S_MMR6 using decoder 166
                                             // 1371:  }
  149, 5, 7,                                 // 1376:  case 0x295: {
  OPC_CheckPredicate, 26,                    // 1379:   check predicate 26
  OPC_Decode, 213, 9, 167, 1,                // 1381:   decode to CMP_SEQ_D_MMR6 using decoder 167
                                             // 1381:  }
  184, 5, 7,                                 // 1386:  case 0x2b8: {
  OPC_CheckPredicate, 3,                     // 1389:   check predicate 3
  OPC_Decode, 239, 19, 173, 1,               // 1391:   decode to SEL_D_MMR6 using decoder 173
                                             // 1391:  }
  197, 5, 7,                                 // 1396:  case 0x2c5: {
  OPC_CheckPredicate, 26,                    // 1399:   check predicate 26
  OPC_Decode, 227, 9, 166, 1,                // 1401:   decode to CMP_SUEQ_S_MMR6 using decoder 166
                                             // 1401:  }
  213, 5, 7,                                 // 1406:  case 0x2d5: {
  OPC_CheckPredicate, 26,                    // 1409:   check predicate 26
  OPC_Decode, 225, 9, 167, 1,                // 1411:   decode to CMP_SUEQ_D_MMR6 using decoder 167
                                             // 1411:  }
  133, 6, 7,                                 // 1416:  case 0x305: {
  OPC_CheckPredicate, 26,                    // 1419:   check predicate 26
  OPC_Decode, 223, 9, 166, 1,                // 1421:   decode to CMP_SLT_S_MMR6 using decoder 166
                                             // 1421:  }
  149, 6, 7,                                 // 1426:  case 0x315: {
  OPC_CheckPredicate, 26,                    // 1429:   check predicate 26
  OPC_Decode, 221, 9, 167, 1,                // 1431:   decode to CMP_SLT_D_MMR6 using decoder 167
                                             // 1431:  }
  187, 6, 147, 1,                            // 1436:  case 0x33b: {
  OPC_SwitchField, 11, 5,                    // 1440:   switch Inst[15:11] {
  0, 7,                                      // 1443:   case 0x0: {
  OPC_CheckPredicate, 26,                    // 1445:    check predicate 26
  OPC_Decode, 159, 13, 128, 1,               // 1447:    decode to FLOOR_L_S_MMR6 using decoder 128
                                             // 1447:   }
  1, 7,                                      // 1452:   case 0x1: {
  OPC_CheckPredicate, 26,                    // 1454:    check predicate 26
  OPC_Decode, 166, 13, 131, 1,               // 1456:    decode to FLOOR_W_S_MMR6 using decoder 131
                                             // 1456:   }
  2, 7,                                      // 1461:   case 0x2: {
  OPC_CheckPredicate, 26,                    // 1463:    check predicate 26
  OPC_Decode, 228, 8, 128, 1,                // 1465:    decode to CEIL_L_S_MMR6 using decoder 128
                                             // 1465:   }
  3, 7,                                      // 1470:   case 0x3: {
  OPC_CheckPredicate, 26,                    // 1472:    check predicate 26
  OPC_Decode, 235, 8, 131, 1,                // 1474:    decode to CEIL_W_S_MMR6 using decoder 131
                                             // 1474:   }
  4, 7,                                      // 1479:   case 0x4: {
  OPC_CheckPredicate, 26,                    // 1481:    check predicate 26
  OPC_Decode, 191, 22, 128, 1,               // 1483:    decode to TRUNC_L_S_MMR6 using decoder 128
                                             // 1483:   }
  5, 7,                                      // 1488:   case 0x5: {
  OPC_CheckPredicate, 26,                    // 1490:    check predicate 26
  OPC_Decode, 198, 22, 131, 1,               // 1492:    decode to TRUNC_W_S_MMR6 using decoder 131
                                             // 1492:   }
  6, 7,                                      // 1497:   case 0x6: {
  OPC_CheckPredicate, 26,                    // 1499:    check predicate 26
  OPC_Decode, 152, 19, 128, 1,               // 1501:    decode to ROUND_L_S_MMR6 using decoder 128
                                             // 1501:   }
  7, 7,                                      // 1506:   case 0x7: {
  OPC_CheckPredicate, 26,                    // 1508:    check predicate 26
  OPC_Decode, 159, 19, 131, 1,               // 1510:    decode to ROUND_W_S_MMR6 using decoder 131
                                             // 1510:   }
  8, 7,                                      // 1515:   case 0x8: {
  OPC_CheckPredicate, 26,                    // 1517:    check predicate 26
  OPC_Decode, 157, 13, 129, 1,               // 1519:    decode to FLOOR_L_D_MMR6 using decoder 129
                                             // 1519:   }
  9, 7,                                      // 1524:   case 0x9: {
  OPC_CheckPredicate, 26,                    // 1526:    check predicate 26
  OPC_Decode, 162, 13, 133, 1,               // 1528:    decode to FLOOR_W_D_MMR6 using decoder 133
                                             // 1528:   }
  10, 7,                                     // 1533:   case 0xa: {
  OPC_CheckPredicate, 26,                    // 1535:    check predicate 26
  OPC_Decode, 226, 8, 129, 1,                // 1537:    decode to CEIL_L_D_MMR6 using decoder 129
                                             // 1537:   }
  11, 7,                                     // 1542:   case 0xb: {
  OPC_CheckPredicate, 26,                    // 1544:    check predicate 26
  OPC_Decode, 231, 8, 133, 1,                // 1546:    decode to CEIL_W_D_MMR6 using decoder 133
                                             // 1546:   }
  12, 7,                                     // 1551:   case 0xc: {
  OPC_CheckPredicate, 26,                    // 1553:    check predicate 26
  OPC_Decode, 189, 22, 129, 1,               // 1555:    decode to TRUNC_L_D_MMR6 using decoder 129
                                             // 1555:   }
  13, 7,                                     // 1560:   case 0xd: {
  OPC_CheckPredicate, 26,                    // 1562:    check predicate 26
  OPC_Decode, 194, 22, 153, 1,               // 1564:    decode to TRUNC_W_D_MMR6 using decoder 153
                                             // 1564:   }
  14, 7,                                     // 1569:   case 0xe: {
  OPC_CheckPredicate, 26,                    // 1571:    check predicate 26
  OPC_Decode, 150, 19, 129, 1,               // 1573:    decode to ROUND_L_D_MMR6 using decoder 129
                                             // 1573:   }
  15, 0,                                     // 1578:   case 0xf: {
  OPC_CheckPredicate, 26,                    // 1580:    check predicate 26
  OPC_Decode, 155, 19, 129, 1,               // 1582:    decode to ROUND_W_D_MMR6 using decoder 129
                                             // 1582:   }
                                             // 1582:   } // switch Inst[15:11]
                                             // 1582:  }
  197, 6, 7,                                 // 1587:  case 0x345: {
  OPC_CheckPredicate, 26,                    // 1590:   check predicate 26
  OPC_Decode, 235, 9, 166, 1,                // 1592:   decode to CMP_SULT_S_MMR6 using decoder 166
                                             // 1592:  }
  213, 6, 7,                                 // 1597:  case 0x355: {
  OPC_CheckPredicate, 26,                    // 1600:   check predicate 26
  OPC_Decode, 233, 9, 167, 1,                // 1602:   decode to CMP_SULT_D_MMR6 using decoder 167
                                             // 1602:  }
  251, 6, 39,                                // 1607:  case 0x37b: {
  OPC_SwitchField, 11, 5,                    // 1610:   switch Inst[15:11] {
  1, 7,                                      // 1613:   case 0x1: {
  OPC_CheckPredicate, 26,                    // 1615:    check predicate 26
  OPC_Decode, 203, 13, 131, 1,               // 1617:    decode to FNEG_S_MMR6 using decoder 131
                                             // 1617:   }
  7, 7,                                      // 1622:   case 0x7: {
  OPC_CheckPredicate, 26,                    // 1624:    check predicate 26
  OPC_Decode, 176, 10, 131, 1,               // 1626:    decode to CVT_S_W_MMR6 using decoder 131
                                             // 1626:   }
  10, 7,                                     // 1631:   case 0xa: {
  OPC_CheckPredicate, 24,                    // 1633:    check predicate 24
  OPC_Decode, 156, 10, 129, 1,               // 1635:    decode to CVT_D_L_MMR6 using decoder 129
                                             // 1635:   }
  11, 0,                                     // 1640:   case 0xb: {
  OPC_CheckPredicate, 24,                    // 1642:    check predicate 24
  OPC_Decode, 171, 10, 128, 1,               // 1644:    decode to CVT_S_L_MMR6 using decoder 128
                                             // 1644:   }
                                             // 1644:   } // switch Inst[15:11]
                                             // 1644:  }
  133, 7, 7,                                 // 1649:  case 0x385: {
  OPC_CheckPredicate, 26,                    // 1652:   check predicate 26
  OPC_Decode, 219, 9, 166, 1,                // 1654:   decode to CMP_SLE_S_MMR6 using decoder 166
                                             // 1654:  }
  149, 7, 7,                                 // 1659:  case 0x395: {
  OPC_CheckPredicate, 26,                    // 1662:   check predicate 26
  OPC_Decode, 217, 9, 167, 1,                // 1664:   decode to CMP_SLE_D_MMR6 using decoder 167
                                             // 1664:  }
  184, 7, 7,                                 // 1669:  case 0x3b8: {
  OPC_CheckPredicate, 26,                    // 1672:   check predicate 26
  OPC_Decode, 224, 15, 174, 1,               // 1674:   decode to MADDF_D_MMR6 using decoder 174
                                             // 1674:  }
  197, 7, 7,                                 // 1679:  case 0x3c5: {
  OPC_CheckPredicate, 26,                    // 1682:   check predicate 26
  OPC_Decode, 231, 9, 166, 1,                // 1684:   decode to CMP_SULE_S_MMR6 using decoder 166
                                             // 1684:  }
  213, 7, 7,                                 // 1689:  case 0x3d5: {
  OPC_CheckPredicate, 26,                    // 1692:   check predicate 26
  OPC_Decode, 229, 9, 167, 1,                // 1694:   decode to CMP_SULE_D_MMR6 using decoder 167
                                             // 1694:  }
  248, 7, 0,                                 // 1699:  case 0x3f8: {
  OPC_CheckPredicate, 26,                    // 1702:   check predicate 26
  OPC_Decode, 147, 17, 174, 1,               // 1704:   decode to MSUBF_D_MMR6 using decoder 174
                                             // 1704:  }
                                             // 1704:  } // switch Inst[10:0]
                                             // 1704: }
  24, 37,                                    // 1709: case 0x18: {
  OPC_SwitchField, 12, 4,                    // 1711:  switch Inst[15:12] {
  2, 6,                                      // 1714:  case 0x2: {
  OPC_CheckPredicate, 3,                     // 1716:   check predicate 3
  OPC_Decode, 240, 18, 107,                  // 1718:   decode to PREF_MMR6 using decoder 107
                                             // 1718:  }
  3, 11,                                     // 1722:  case 0x3: {
  OPC_CheckPredicate, 3,                     // 1724:   check predicate 3
  OPC_CheckField, 9, 3, 0,                   // 1726:   check Inst[11:9] == 0x0
  OPC_Decode, 158, 15, 141, 1,               // 1730:   decode to LL_MMR6 using decoder 141
                                             // 1730:  }
  11, 0,                                     // 1735:  case 0xb: {
  OPC_CheckPredicate, 3,                     // 1737:   check predicate 3
  OPC_CheckField, 9, 3, 0,                   // 1739:   check Inst[11:9] == 0x0
  OPC_Decode, 194, 19, 141, 1,               // 1743:   decode to SC_MMR6 using decoder 141
                                             // 1743:  }
                                             // 1743:  } // switch Inst[15:12]
                                             // 1743: }
  28, 6,                                     // 1748: case 0x1c: {
  OPC_CheckPredicate, 3,                     // 1750:  check predicate 3
  OPC_Decode, 223, 22, 115,                  // 1752:  decode to XORI_MMR6 using decoder 115
                                             // 1752: }
  29, 20,                                    // 1756: case 0x1d: {
  OPC_Scope, 11,                             // 1758:  try {
  OPC_CheckField, 16, 5, 0,                  // 1760:   check Inst[20:16] == 0x0
  OPC_CheckPredicate, 3,                     // 1764:   check predicate 3
  OPC_Decode, 194, 7, 175, 1,                // 1766:   decode to BEQZALC_MMR6 using decoder 175
                                             // 1766:  } else try {
  OPC_CheckPredicate, 3,                     // 1771:   check predicate 3
  OPC_Decode, 190, 7, 175, 1,                // 1773:   decode to BEQC_MMR6 using decoder 175
                                             // 1773:  }
                                             // 1773: }
  30, 44,                                    // 1778: case 0x1e: {
  OPC_SwitchField, 19, 2,                    // 1780:  switch Inst[20:19] {
  0, 7,                                      // 1783:  case 0x0: {
  OPC_CheckPredicate, 3,                     // 1785:   check predicate 3
  OPC_Decode, 149, 6, 176, 1,                // 1787:   decode to ADDIUPC_MMR6 using decoder 176
                                             // 1787:  }
  1, 7,                                      // 1792:  case 0x1: {
  OPC_CheckPredicate, 3,                     // 1794:   check predicate 3
  OPC_Decode, 193, 15, 176, 1,               // 1796:   decode to LWPC_MMR6 using decoder 176
                                             // 1796:  }
  3, 0,                                      // 1801:  case 0x3: {
  OPC_SwitchField, 16, 3,                    // 1803:   switch Inst[18:16] {
  6, 7,                                      // 1806:   case 0x6: {
  OPC_CheckPredicate, 3,                     // 1808:    check predicate 3
  OPC_Decode, 251, 6, 177, 1,                // 1810:    decode to AUIPC_MMR6 using decoder 177
                                             // 1810:   }
  7, 0,                                      // 1815:   case 0x7: {
  OPC_CheckPredicate, 3,                     // 1817:    check predicate 3
  OPC_Decode, 224, 6, 177, 1,                // 1819:    decode to ALUIPC_MMR6 using decoder 177
                                             // 1819:   }
                                             // 1819:   } // switch Inst[18:16]
                                             // 1819:  }
                                             // 1819:  } // switch Inst[20:19]
                                             // 1819: }
  31, 20,                                    // 1824: case 0x1f: {
  OPC_Scope, 11,                             // 1826:  try {
  OPC_CheckField, 16, 5, 0,                  // 1828:   check Inst[20:16] == 0x0
  OPC_CheckPredicate, 3,                     // 1832:   check predicate 3
  OPC_Decode, 169, 8, 178, 1,                // 1834:   decode to BNEZALC_MMR6 using decoder 178
                                             // 1834:  } else try {
  OPC_CheckPredicate, 3,                     // 1839:   check predicate 3
  OPC_Decode, 157, 8, 178, 1,                // 1841:   decode to BNEC_MMR6 using decoder 178
                                             // 1841:  }
                                             // 1841: }
  32, 19,                                    // 1846: case 0x20: {
  OPC_Scope, 10,                             // 1848:  try {
  OPC_CheckField, 21, 5, 0,                  // 1850:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 3,                     // 1854:   check predicate 3
  OPC_Decode, 199, 14, 110,                  // 1856:   decode to JIALC_MMR6 using decoder 110
                                             // 1856:  } else try {
  OPC_CheckPredicate, 3,                     // 1860:   check predicate 3
  OPC_Decode, 199, 7, 179, 1,                // 1862:   decode to BEQZC_MMR6 using decoder 179
                                             // 1862:  }
                                             // 1862: }
  37, 7,                                     // 1867: case 0x25: {
  OPC_CheckPredicate, 3,                     // 1869:  check predicate 3
  OPC_Decode, 185, 7, 180, 1,                // 1871:  decode to BC_MMR6 using decoder 180
                                             // 1871: }
  40, 19,                                    // 1876: case 0x28: {
  OPC_Scope, 10,                             // 1878:  try {
  OPC_CheckField, 21, 5, 0,                  // 1880:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 3,                     // 1884:   check predicate 3
  OPC_Decode, 202, 14, 110,                  // 1886:   decode to JIC_MMR6 using decoder 110
                                             // 1886:  } else try {
  OPC_CheckPredicate, 3,                     // 1890:   check predicate 3
  OPC_Decode, 174, 8, 179, 1,                // 1892:   decode to BNEZC_MMR6 using decoder 179
                                             // 1892:  }
                                             // 1892: }
  45, 7,                                     // 1897: case 0x2d: {
  OPC_CheckPredicate, 3,                     // 1899:  check predicate 3
  OPC_Decode, 154, 7, 180, 1,                // 1901:  decode to BALC_MMR6 using decoder 180
                                             // 1901: }
  48, 7,                                     // 1906: case 0x30: {
  OPC_CheckPredicate, 3,                     // 1908:  check predicate 3
  OPC_Decode, 206, 7, 181, 1,                // 1910:  decode to BGEUC_MMR6 using decoder 181
                                             // 1910: }
  52, 6,                                     // 1915: case 0x34: {
  OPC_CheckPredicate, 3,                     // 1917:  check predicate 3
  OPC_Decode, 232, 6, 115,                   // 1919:  decode to ANDI_MMR6 using decoder 115
                                             // 1919: }
  53, 7,                                     // 1923: case 0x35: {
  OPC_CheckPredicate, 3,                     // 1925:  check predicate 3
  OPC_Decode, 132, 8, 182, 1,                // 1927:  decode to BLTC_MMR6 using decoder 182
                                             // 1927: }
  56, 7,                                     // 1932: case 0x38: {
  OPC_CheckPredicate, 3,                     // 1934:  check predicate 3
  OPC_Decode, 135, 8, 183, 1,                // 1936:  decode to BLTUC_MMR6 using decoder 183
                                             // 1936: }
  61, 7,                                     // 1941: case 0x3d: {
  OPC_CheckPredicate, 3,                     // 1943:  check predicate 3
  OPC_Decode, 203, 7, 184, 1,                // 1945:  decode to BGEC_MMR6 using decoder 184
                                             // 1945: }
  62, 6,                                     // 1950: case 0x3e: {
  OPC_CheckPredicate, 3,                     // 1952:  check predicate 3
  OPC_Decode, 239, 21, 105,                  // 1954:  decode to SW_MMR6 using decoder 105
                                             // 1954: }
  63, 0,                                     // 1958: case 0x3f: {
  OPC_CheckPredicate, 3,                     // 1960:  check predicate 3
  OPC_Decode, 209, 15, 105,                  // 1962:  decode to LW_MMR6 using decoder 105
                                             // 1962: }
                                             // 1962: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMicroMipsR6_Ambiguous32[65] = {
  OPC_SwitchField, 26, 6,                    //  0: switch Inst[31:26] {
  29, 7,                                     //  3: case 0x1d: {
  OPC_CheckPredicate, 3,                     //  5:  check predicate 3
  OPC_Decode, 184, 8, 175, 1,                //  7:  decode to BOVC_MMR6 using decoder 175
                                             //  7: }
  31, 7,                                     // 12: case 0x1f: {
  OPC_CheckPredicate, 3,                     // 14:  check predicate 3
  OPC_Decode, 177, 8, 178, 1,                // 16:  decode to BNVC_MMR6 using decoder 178
                                             // 16: }
  48, 20,                                    // 21: case 0x30: {
  OPC_Scope, 11,                             // 23:  try {
  OPC_CheckField, 16, 5, 0,                  // 25:   check Inst[20:16] == 0x0
  OPC_CheckPredicate, 3,                     // 29:   check predicate 3
  OPC_Decode, 252, 7, 181, 1,                // 31:   decode to BLEZALC_MMR6 using decoder 181
                                             // 31:  } else try {
  OPC_CheckPredicate, 3,                     // 36:   check predicate 3
  OPC_Decode, 211, 7, 181, 1,                // 38:   decode to BGEZALC_MMR6 using decoder 181
                                             // 38:  }
                                             // 38: }
  56, 0,                                     // 43: case 0x38: {
  OPC_Scope, 11,                             // 45:  try {
  OPC_CheckField, 16, 5, 0,                  // 47:   check Inst[20:16] == 0x0
  OPC_CheckPredicate, 3,                     // 51:   check predicate 3
  OPC_Decode, 223, 7, 183, 1,                // 53:   decode to BGTZALC_MMR6 using decoder 183
                                             // 53:  } else try {
  OPC_CheckPredicate, 3,                     // 58:   check predicate 3
  OPC_Decode, 140, 8, 183, 1,                // 60:   decode to BLTZALC_MMR6 using decoder 183
                                             // 60:  }
                                             // 60: }
                                             // 60: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMips32[10270] = {
  OPC_SwitchField, 26, 6,                    //     0: switch Inst[31:26] {
  0, 159, 5,                                 //     3: case 0x0: {
  OPC_SwitchField, 0, 6,                     //     6:  switch Inst[5:0] {
  0, 40,                                     //     9:  case 0x0: {
  OPC_CheckField, 21, 5, 0,                  //    11:   check Inst[25:21] == 0x0
  OPC_Scope, 27,                             //    15:   try {
  OPC_SwitchField, 6, 15,                    //    17:    switch Inst[20:6] {
  1, 6,                                      //    20:    case 0x1: {
  OPC_CheckPredicate, 27,                    //    22:     check predicate 27
  OPC_Decode, 138, 21, 10,                   //    24:     decode to SSNOP using decoder 10
                                             //    24:    }
  3, 6,                                      //    28:    case 0x3: {
  OPC_CheckPredicate, 27,                    //    30:     check predicate 27
  OPC_Decode, 164, 12, 10,                   //    32:     decode to EHB using decoder 10
                                             //    32:    }
  5, 0,                                      //    36:    case 0x5: {
  OPC_CheckPredicate, 28,                    //    38:     check predicate 28
  OPC_Decode, 179, 18, 10,                   //    40:     decode to PAUSE using decoder 10
                                             //    40:    }
                                             //    40:    } // switch Inst[20:6]
                                             //    40:   } else try {
  OPC_CheckPredicate, 27,                    //    44:    check predicate 27
  OPC_Decode, 185, 20, 185, 1,               //    46:    decode to SLL using decoder 185
                                             //    46:   }
                                             //    46:  }
  1, 29,                                     //    51:  case 0x1: {
  OPC_SwitchField, 16, 2,                    //    53:   switch Inst[17:16] {
  0, 11,                                     //    56:   case 0x0: {
  OPC_CheckPredicate, 29,                    //    58:    check predicate 29
  OPC_CheckField, 6, 5, 0,                   //    60:    check Inst[10:6] == 0x0
  OPC_Decode, 236, 16, 186, 1,               //    64:    decode to MOVF_I using decoder 186
                                             //    64:   }
  1, 0,                                      //    69:   case 0x1: {
  OPC_CheckPredicate, 29,                    //    71:    check predicate 29
  OPC_CheckField, 6, 5, 0,                   //    73:    check Inst[10:6] == 0x0
  OPC_Decode, 128, 17, 186, 1,               //    77:    decode to MOVT_I using decoder 186
                                             //    77:   }
                                             //    77:   } // switch Inst[17:16]
                                             //    77:  }
  2, 21,                                     //    82:  case 0x2: {
  OPC_SwitchField, 21, 5,                    //    84:   switch Inst[25:21] {
  0, 7,                                      //    87:   case 0x0: {
  OPC_CheckPredicate, 27,                    //    89:    check predicate 27
  OPC_Decode, 244, 20, 185, 1,               //    91:    decode to SRL using decoder 185
                                             //    91:   }
  1, 0,                                      //    96:   case 0x1: {
  OPC_CheckPredicate, 28,                    //    98:    check predicate 28
  OPC_Decode, 145, 19, 185, 1,               //   100:    decode to ROTR using decoder 185
                                             //   100:   }
                                             //   100:   } // switch Inst[25:21]
                                             //   100:  }
  3, 11,                                     //   105:  case 0x3: {
  OPC_CheckPredicate, 27,                    //   107:   check predicate 27
  OPC_CheckField, 21, 5, 0,                  //   109:   check Inst[25:21] == 0x0
  OPC_Decode, 224, 20, 185, 1,               //   113:   decode to SRA using decoder 185
                                             //   113:  }
  4, 10,                                     //   118:  case 0x4: {
  OPC_CheckPredicate, 27,                    //   120:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   122:   check Inst[10:6] == 0x0
  OPC_Decode, 194, 20, 61,                   //   126:   decode to SLLV using decoder 61
                                             //   126:  }
  5, 11,                                     //   130:  case 0x5: {
  OPC_CheckPredicate, 30,                    //   132:   check predicate 30
  OPC_CheckField, 8, 3, 0,                   //   134:   check Inst[10:8] == 0x0
  OPC_Decode, 160, 15, 187, 1,               //   138:   decode to LSA using decoder 187
                                             //   138:  }
  6, 19,                                     //   143:  case 0x6: {
  OPC_SwitchField, 6, 5,                     //   145:   switch Inst[10:6] {
  0, 6,                                      //   148:   case 0x0: {
  OPC_CheckPredicate, 27,                    //   150:    check predicate 27
  OPC_Decode, 131, 21, 61,                   //   152:    decode to SRLV using decoder 61
                                             //   152:   }
  1, 0,                                      //   156:   case 0x1: {
  OPC_CheckPredicate, 28,                    //   158:    check predicate 28
  OPC_Decode, 146, 19, 61,                   //   160:    decode to ROTRV using decoder 61
                                             //   160:   }
                                             //   160:   } // switch Inst[10:6]
                                             //   160:  }
  7, 10,                                     //   164:  case 0x7: {
  OPC_CheckPredicate, 27,                    //   166:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   168:   check Inst[10:6] == 0x0
  OPC_Decode, 237, 20, 61,                   //   172:   decode to SRAV using decoder 61
                                             //   172:  }
  8, 21,                                     //   176:  case 0x8: {
  OPC_SwitchField, 6, 15,                    //   178:   switch Inst[20:6] {
  0, 7,                                      //   181:   case 0x0: {
  OPC_CheckPredicate, 31,                    //   183:    check predicate 31
  OPC_Decode, 203, 14, 188, 1,               //   185:    decode to JR using decoder 188
                                             //   185:   }
  16, 0,                                     //   190:   case 0x10: {
  OPC_CheckPredicate, 32,                    //   192:    check predicate 32
  OPC_Decode, 210, 14, 188, 1,               //   194:    decode to JR_HB using decoder 188
                                             //   194:   }
                                             //   194:   } // switch Inst[20:6]
                                             //   194:  }
  9, 27,                                     //   199:  case 0x9: {
  OPC_SwitchField, 6, 5,                     //   201:   switch Inst[10:6] {
  0, 10,                                     //   204:   case 0x0: {
  OPC_CheckPredicate, 33,                    //   206:    check predicate 33
  OPC_CheckField, 16, 5, 0,                  //   208:    check Inst[20:16] == 0x0
  OPC_Decode, 182, 14, 52,                   //   212:    decode to JALR using decoder 52
                                             //   212:   }
  16, 0,                                     //   216:   case 0x10: {
  OPC_CheckPredicate, 34,                    //   218:    check predicate 34
  OPC_CheckField, 16, 5, 0,                  //   220:    check Inst[20:16] == 0x0
  OPC_Decode, 190, 14, 52,                   //   224:    decode to JALR_HB using decoder 52
                                             //   224:   }
                                             //   224:   } // switch Inst[10:6]
                                             //   224:  }
  10, 11,                                    //   228:  case 0xa: {
  OPC_CheckPredicate, 35,                    //   230:   check predicate 35
  OPC_CheckField, 6, 5, 0,                   //   232:   check Inst[10:6] == 0x0
  OPC_Decode, 140, 17, 189, 1,               //   236:   decode to MOVZ_I_I using decoder 189
                                             //   236:  }
  11, 11,                                    //   241:  case 0xb: {
  OPC_CheckPredicate, 35,                    //   243:   check predicate 35
  OPC_CheckField, 6, 5, 0,                   //   245:   check Inst[10:6] == 0x0
  OPC_Decode, 248, 16, 189, 1,               //   249:   decode to MOVN_I_I using decoder 189
                                             //   249:  }
  12, 7,                                     //   254:  case 0xc: {
  OPC_CheckPredicate, 27,                    //   256:   check predicate 27
  OPC_Decode, 246, 21, 190, 1,               //   258:   decode to SYSCALL using decoder 190
                                             //   258:  }
  13, 6,                                     //   263:  case 0xd: {
  OPC_CheckPredicate, 27,                    //   265:   check predicate 27
  OPC_Decode, 188, 8, 62,                    //   267:   decode to BREAK using decoder 62
                                             //   267:  }
  15, 7,                                     //   271:  case 0xf: {
  OPC_CheckPredicate, 36,                    //   273:   check predicate 36
  OPC_Decode, 240, 21, 191, 1,               //   275:   decode to SYNC using decoder 191
                                             //   275:  }
  16, 32,                                    //   280:  case 0x10: {
  OPC_CheckField, 6, 5, 0,                   //   282:   check Inst[10:6] == 0x0
  OPC_CheckField, 16, 5, 0,                  //   286:   check Inst[20:16] == 0x0
  OPC_CheckField, 23, 3, 0,                  //   290:   check Inst[25:23] == 0x0
  OPC_Scope, 11,                             //   294:   try {
  OPC_CheckField, 21, 2, 0,                  //   296:    check Inst[22:21] == 0x0
  OPC_CheckPredicate, 31,                    //   300:    check predicate 31
  OPC_Decode, 173, 16, 192, 1,               //   302:    decode to MFHI using decoder 192
                                             //   302:   } else try {
  OPC_CheckPredicate, 37,                    //   307:    check predicate 37
  OPC_Decode, 176, 16, 193, 1,               //   309:    decode to MFHI_DSP using decoder 193
                                             //   309:   }
                                             //   309:  }
  17, 28,                                    //   314:  case 0x11: {
  OPC_CheckField, 6, 5, 0,                   //   316:   check Inst[10:6] == 0x0
  OPC_CheckField, 13, 8, 0,                  //   320:   check Inst[20:13] == 0x0
  OPC_Scope, 11,                             //   324:   try {
  OPC_CheckField, 11, 2, 0,                  //   326:    check Inst[12:11] == 0x0
  OPC_CheckPredicate, 31,                    //   330:    check predicate 31
  OPC_Decode, 189, 17, 188, 1,               //   332:    decode to MTHI using decoder 188
                                             //   332:   } else try {
  OPC_CheckPredicate, 37,                    //   337:    check predicate 37
  OPC_Decode, 191, 17, 194, 1,               //   339:    decode to MTHI_DSP using decoder 194
                                             //   339:   }
                                             //   339:  }
  18, 32,                                    //   344:  case 0x12: {
  OPC_CheckField, 6, 5, 0,                   //   346:   check Inst[10:6] == 0x0
  OPC_CheckField, 16, 5, 0,                  //   350:   check Inst[20:16] == 0x0
  OPC_CheckField, 23, 3, 0,                  //   354:   check Inst[25:23] == 0x0
  OPC_Scope, 11,                             //   358:   try {
  OPC_CheckField, 21, 2, 0,                  //   360:    check Inst[22:21] == 0x0
  OPC_CheckPredicate, 31,                    //   364:    check predicate 31
  OPC_Decode, 179, 16, 192, 1,               //   366:    decode to MFLO using decoder 192
                                             //   366:   } else try {
  OPC_CheckPredicate, 37,                    //   371:    check predicate 37
  OPC_Decode, 182, 16, 193, 1,               //   373:    decode to MFLO_DSP using decoder 193
                                             //   373:   }
                                             //   373:  }
  19, 28,                                    //   378:  case 0x13: {
  OPC_CheckField, 6, 5, 0,                   //   380:   check Inst[10:6] == 0x0
  OPC_CheckField, 13, 8, 0,                  //   384:   check Inst[20:13] == 0x0
  OPC_Scope, 11,                             //   388:   try {
  OPC_CheckField, 11, 2, 0,                  //   390:    check Inst[12:11] == 0x0
  OPC_CheckPredicate, 31,                    //   394:    check predicate 31
  OPC_Decode, 196, 17, 188, 1,               //   396:    decode to MTLO using decoder 188
                                             //   396:   } else try {
  OPC_CheckPredicate, 37,                    //   401:    check predicate 37
  OPC_Decode, 198, 17, 195, 1,               //   403:    decode to MTLO_DSP using decoder 195
                                             //   403:   }
                                             //   403:  }
  21, 11,                                    //   408:  case 0x15: {
  OPC_CheckPredicate, 38,                    //   410:   check predicate 38
  OPC_CheckField, 8, 3, 0,                   //   412:   check Inst[10:8] == 0x0
  OPC_Decode, 195, 11, 196, 1,               //   416:   decode to DLSA using decoder 196
                                             //   416:  }
  24, 27,                                    //   421:  case 0x18: {
  OPC_CheckField, 6, 5, 0,                   //   423:   check Inst[10:6] == 0x0
  OPC_CheckField, 13, 3, 0,                  //   427:   check Inst[15:13] == 0x0
  OPC_Scope, 10,                             //   431:   try {
  OPC_CheckField, 11, 2, 0,                  //   433:    check Inst[12:11] == 0x0
  OPC_CheckPredicate, 31,                    //   437:    check predicate 31
  OPC_Decode, 236, 17, 86,                   //   439:    decode to MULT using decoder 86
                                             //   439:   } else try {
  OPC_CheckPredicate, 37,                    //   443:    check predicate 37
  OPC_Decode, 239, 17, 197, 1,               //   445:    decode to MULT_DSP using decoder 197
                                             //   445:   }
                                             //   445:  }
  25, 27,                                    //   450:  case 0x19: {
  OPC_CheckField, 6, 5, 0,                   //   452:   check Inst[10:6] == 0x0
  OPC_CheckField, 13, 3, 0,                  //   456:   check Inst[15:13] == 0x0
  OPC_Scope, 10,                             //   460:   try {
  OPC_CheckField, 11, 2, 0,                  //   462:    check Inst[12:11] == 0x0
  OPC_CheckPredicate, 31,                    //   466:    check predicate 31
  OPC_Decode, 242, 17, 86,                   //   468:    decode to MULTu using decoder 86
                                             //   468:   } else try {
  OPC_CheckPredicate, 37,                    //   472:    check predicate 37
  OPC_Decode, 237, 17, 197, 1,               //   474:    decode to MULTU_DSP using decoder 197
                                             //   474:   }
                                             //   474:  }
  26, 10,                                    //   479:  case 0x1a: {
  OPC_CheckPredicate, 31,                    //   481:   check predicate 31
  OPC_CheckField, 6, 10, 0,                  //   483:   check Inst[15:6] == 0x0
  OPC_Decode, 212, 19, 86,                   //   487:   decode to SDIV using decoder 86
                                             //   487:  }
  27, 10,                                    //   491:  case 0x1b: {
  OPC_CheckPredicate, 31,                    //   493:   check predicate 31
  OPC_CheckField, 6, 10, 0,                  //   495:   check Inst[15:6] == 0x0
  OPC_Decode, 200, 22, 86,                   //   499:   decode to UDIV using decoder 86
                                             //   499:  }
  32, 10,                                    //   503:  case 0x20: {
  OPC_CheckPredicate, 27,                    //   505:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   507:   check Inst[10:6] == 0x0
  OPC_Decode, 146, 6, 67,                    //   511:   decode to ADD using decoder 67
                                             //   511:  }
  33, 10,                                    //   515:  case 0x21: {
  OPC_CheckPredicate, 27,                    //   517:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   519:   check Inst[10:6] == 0x0
  OPC_Decode, 219, 6, 67,                    //   523:   decode to ADDu using decoder 67
                                             //   523:  }
  34, 10,                                    //   527:  case 0x22: {
  OPC_CheckPredicate, 27,                    //   529:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   531:   check Inst[10:6] == 0x0
  OPC_Decode, 145, 21, 67,                   //   535:   decode to SUB using decoder 67
                                             //   535:  }
  35, 10,                                    //   539:  case 0x23: {
  OPC_CheckPredicate, 27,                    //   541:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   543:   check Inst[10:6] == 0x0
  OPC_Decode, 201, 21, 67,                   //   547:   decode to SUBu using decoder 67
                                             //   547:  }
  36, 10,                                    //   551:  case 0x24: {
  OPC_CheckPredicate, 27,                    //   553:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   555:   check Inst[10:6] == 0x0
  OPC_Decode, 225, 6, 67,                    //   559:   decode to AND using decoder 67
                                             //   559:  }
  37, 10,                                    //   563:  case 0x25: {
  OPC_CheckPredicate, 27,                    //   565:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   567:   check Inst[10:6] == 0x0
  OPC_Decode, 164, 18, 67,                   //   571:   decode to OR using decoder 67
                                             //   571:  }
  38, 10,                                    //   575:  case 0x26: {
  OPC_CheckPredicate, 27,                    //   577:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   579:   check Inst[10:6] == 0x0
  OPC_Decode, 218, 22, 67,                   //   583:   decode to XOR using decoder 67
                                             //   583:  }
  39, 10,                                    //   587:  case 0x27: {
  OPC_CheckPredicate, 27,                    //   589:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   591:   check Inst[10:6] == 0x0
  OPC_Decode, 154, 18, 67,                   //   595:   decode to NOR using decoder 67
                                             //   595:  }
  42, 10,                                    //   599:  case 0x2a: {
  OPC_CheckPredicate, 27,                    //   601:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   603:   check Inst[10:6] == 0x0
  OPC_Decode, 202, 20, 67,                   //   607:   decode to SLT using decoder 67
                                             //   607:  }
  43, 10,                                    //   611:  case 0x2b: {
  OPC_CheckPredicate, 27,                    //   613:   check predicate 27
  OPC_CheckField, 6, 5, 0,                   //   615:   check Inst[10:6] == 0x0
  OPC_Decode, 211, 20, 67,                   //   619:   decode to SLTu using decoder 67
                                             //   619:  }
  48, 7,                                     //   623:  case 0x30: {
  OPC_CheckPredicate, 36,                    //   625:   check predicate 36
  OPC_Decode, 145, 22, 198, 1,               //   627:   decode to TGE using decoder 198
                                             //   627:  }
  49, 7,                                     //   632:  case 0x31: {
  OPC_CheckPredicate, 36,                    //   634:   check predicate 36
  OPC_Decode, 150, 22, 198, 1,               //   636:   decode to TGEU using decoder 198
                                             //   636:  }
  50, 7,                                     //   641:  case 0x32: {
  OPC_CheckPredicate, 36,                    //   643:   check predicate 36
  OPC_Decode, 177, 22, 198, 1,               //   645:   decode to TLT using decoder 198
                                             //   645:  }
  51, 7,                                     //   650:  case 0x33: {
  OPC_CheckPredicate, 36,                    //   652:   check predicate 36
  OPC_Decode, 181, 22, 198, 1,               //   654:   decode to TLTU using decoder 198
                                             //   654:  }
  52, 7,                                     //   659:  case 0x34: {
  OPC_CheckPredicate, 36,                    //   661:   check predicate 36
  OPC_Decode, 141, 22, 198, 1,               //   663:   decode to TEQ using decoder 198
                                             //   663:  }
  54, 0,                                     //   668:  case 0x36: {
  OPC_CheckPredicate, 36,                    //   670:   check predicate 36
  OPC_Decode, 184, 22, 198, 1,               //   672:   decode to TNE using decoder 198
                                             //   672:  }
                                             //   672:  } // switch Inst[5:0]
                                             //   672: }
  1, 151, 1,                                 //   677: case 0x1: {
  OPC_SwitchField, 16, 5,                    //   680:  switch Inst[20:16] {
  0, 7,                                      //   683:  case 0x0: {
  OPC_CheckPredicate, 27,                    //   685:   check predicate 27
  OPC_Decode, 136, 8, 199, 1,                //   687:   decode to BLTZ using decoder 199
                                             //   687:  }
  1, 7,                                      //   692:  case 0x1: {
  OPC_CheckPredicate, 27,                    //   694:   check predicate 27
  OPC_Decode, 207, 7, 199, 1,                //   696:   decode to BGEZ using decoder 199
                                             //   696:  }
  2, 7,                                      //   701:  case 0x2: {
  OPC_CheckPredicate, 39,                    //   703:   check predicate 39
  OPC_Decode, 147, 8, 199, 1,                //   705:   decode to BLTZL using decoder 199
                                             //   705:  }
  3, 7,                                      //   710:  case 0x3: {
  OPC_CheckPredicate, 39,                    //   712:   check predicate 39
  OPC_Decode, 218, 7, 199, 1,                //   714:   decode to BGEZL using decoder 199
                                             //   714:  }
  8, 7,                                      //   719:  case 0x8: {
  OPC_CheckPredicate, 39,                    //   721:   check predicate 39
  OPC_Decode, 146, 22, 177, 1,               //   723:   decode to TGEI using decoder 177
                                             //   723:  }
  9, 7,                                      //   728:  case 0x9: {
  OPC_CheckPredicate, 39,                    //   730:   check predicate 39
  OPC_Decode, 147, 22, 177, 1,               //   732:   decode to TGEIU using decoder 177
                                             //   732:  }
  10, 7,                                     //   737:  case 0xa: {
  OPC_CheckPredicate, 39,                    //   739:   check predicate 39
  OPC_Decode, 178, 22, 177, 1,               //   741:   decode to TLTI using decoder 177
                                             //   741:  }
  11, 7,                                     //   746:  case 0xb: {
  OPC_CheckPredicate, 39,                    //   748:   check predicate 39
  OPC_Decode, 199, 22, 177, 1,               //   750:   decode to TTLTIU using decoder 177
                                             //   750:  }
  12, 7,                                     //   755:  case 0xc: {
  OPC_CheckPredicate, 39,                    //   757:   check predicate 39
  OPC_Decode, 142, 22, 177, 1,               //   759:   decode to TEQI using decoder 177
                                             //   759:  }
  14, 7,                                     //   764:  case 0xe: {
  OPC_CheckPredicate, 39,                    //   766:   check predicate 39
  OPC_Decode, 185, 22, 177, 1,               //   768:   decode to TNEI using decoder 177
                                             //   768:  }
  16, 7,                                     //   773:  case 0x10: {
  OPC_CheckPredicate, 31,                    //   775:   check predicate 31
  OPC_Decode, 138, 8, 199, 1,                //   777:   decode to BLTZAL using decoder 199
                                             //   777:  }
  17, 7,                                     //   782:  case 0x11: {
  OPC_CheckPredicate, 31,                    //   784:   check predicate 31
  OPC_Decode, 209, 7, 199, 1,                //   786:   decode to BGEZAL using decoder 199
                                             //   786:  }
  18, 7,                                     //   791:  case 0x12: {
  OPC_CheckPredicate, 39,                    //   793:   check predicate 39
  OPC_Decode, 141, 8, 199, 1,                //   795:   decode to BLTZALL using decoder 199
                                             //   795:  }
  19, 7,                                     //   800:  case 0x13: {
  OPC_CheckPredicate, 39,                    //   802:   check predicate 39
  OPC_Decode, 212, 7, 199, 1,                //   804:   decode to BGEZALL using decoder 199
                                             //   804:  }
  28, 11,                                    //   809:  case 0x1c: {
  OPC_CheckPredicate, 40,                    //   811:   check predicate 40
  OPC_CheckField, 21, 5, 0,                  //   813:   check Inst[25:21] == 0x0
  OPC_Decode, 185, 8, 200, 1,                //   817:   decode to BPOSGE32 using decoder 200
                                             //   817:  }
  31, 0,                                     //   822:  case 0x1f: {
  OPC_CheckPredicate, 28,                    //   824:   check predicate 28
  OPC_Decode, 241, 21, 201, 1,               //   826:   decode to SYNCI using decoder 201
                                             //   826:  }
                                             //   826:  } // switch Inst[20:16]
                                             //   826: }
  2, 7,                                      //   831: case 0x2: {
  OPC_CheckPredicate, 27,                    //   833:  check predicate 27
  OPC_Decode, 180, 14, 202, 1,               //   835:  decode to J using decoder 202
                                             //   835: }
  3, 7,                                      //   840: case 0x3: {
  OPC_CheckPredicate, 27,                    //   842:  check predicate 27
  OPC_Decode, 181, 14, 202, 1,               //   844:  decode to JAL using decoder 202
                                             //   844: }
  4, 7,                                      //   849: case 0x4: {
  OPC_CheckPredicate, 27,                    //   851:  check predicate 27
  OPC_Decode, 186, 7, 203, 1,                //   853:  decode to BEQ using decoder 203
                                             //   853: }
  5, 7,                                      //   858: case 0x5: {
  OPC_CheckPredicate, 27,                    //   860:  check predicate 27
  OPC_Decode, 153, 8, 203, 1,                //   862:  decode to BNE using decoder 203
                                             //   862: }
  6, 11,                                     //   867: case 0x6: {
  OPC_CheckPredicate, 27,                    //   869:  check predicate 27
  OPC_CheckField, 16, 5, 0,                  //   871:  check Inst[20:16] == 0x0
  OPC_Decode, 249, 7, 199, 1,                //   875:  decode to BLEZ using decoder 199
                                             //   875: }
  7, 11,                                     //   880: case 0x7: {
  OPC_CheckPredicate, 27,                    //   882:  check predicate 27
  OPC_CheckField, 16, 5, 0,                  //   884:  check Inst[20:16] == 0x0
  OPC_Decode, 220, 7, 199, 1,                //   888:  decode to BGTZ using decoder 199
                                             //   888: }
  8, 7,                                      //   893: case 0x8: {
  OPC_CheckPredicate, 31,                    //   895:  check predicate 31
  OPC_Decode, 215, 6, 204, 1,                //   897:  decode to ADDi using decoder 204
                                             //   897: }
  9, 7,                                      //   902: case 0x9: {
  OPC_CheckPredicate, 27,                    //   904:  check predicate 27
  OPC_Decode, 217, 6, 204, 1,                //   906:  decode to ADDiu using decoder 204
                                             //   906: }
  10, 7,                                     //   911: case 0xa: {
  OPC_CheckPredicate, 27,                    //   913:  check predicate 27
  OPC_Decode, 205, 20, 204, 1,               //   915:  decode to SLTi using decoder 204
                                             //   915: }
  11, 7,                                     //   920: case 0xb: {
  OPC_CheckPredicate, 27,                    //   922:  check predicate 27
  OPC_Decode, 208, 20, 204, 1,               //   924:  decode to SLTiu using decoder 204
                                             //   924: }
  12, 7,                                     //   929: case 0xc: {
  OPC_CheckPredicate, 27,                    //   931:  check predicate 27
  OPC_Decode, 236, 6, 205, 1,                //   933:  decode to ANDi using decoder 205
                                             //   933: }
  13, 7,                                     //   938: case 0xd: {
  OPC_CheckPredicate, 27,                    //   940:  check predicate 27
  OPC_Decode, 173, 18, 205, 1,               //   942:  decode to ORi using decoder 205
                                             //   942: }
  14, 7,                                     //   947: case 0xe: {
  OPC_CheckPredicate, 27,                    //   949:  check predicate 27
  OPC_Decode, 227, 22, 205, 1,               //   951:  decode to XORi using decoder 205
                                             //   951: }
  15, 10,                                    //   956: case 0xf: {
  OPC_CheckPredicate, 27,                    //   958:  check predicate 27
  OPC_CheckField, 21, 5, 0,                  //   960:  check Inst[25:21] == 0x0
  OPC_Decode, 167, 15, 110,                  //   964:  decode to LUi using decoder 110
                                             //   964: }
  16, 165, 3,                                //   968: case 0x10: {
  OPC_SwitchField, 3, 1,                     //   971:  switch Inst[3] {
  0, 135, 2,                                 //   974:  case 0x0: {
  OPC_SwitchField, 21, 5,                    //   977:   switch Inst[25:21] {
  0, 11,                                     //   980:   case 0x0: {
  OPC_CheckPredicate, 27,                    //   982:    check predicate 27
  OPC_CheckField, 4, 7, 0,                   //   984:    check Inst[10:4] == 0x0
  OPC_Decode, 155, 16, 206, 1,               //   988:    decode to MFC0 using decoder 206
                                             //   988:   }
  3, 39,                                     //   993:   case 0x3: {
  OPC_SwitchField, 4, 7,                     //   995:    switch Inst[10:4] {
  0, 7,                                      //   998:    case 0x0: {
  OPC_CheckPredicate, 41,                    //  1000:     check predicate 41
  OPC_Decode, 163, 16, 206, 1,               //  1002:     decode to MFGC0 using decoder 206
                                             //  1002:    }
  32, 7,                                     //  1007:    case 0x20: {
  OPC_CheckPredicate, 41,                    //  1009:     check predicate 41
  OPC_Decode, 179, 17, 207, 1,               //  1011:     decode to MTGC0 using decoder 207
                                             //  1011:    }
  64, 7,                                     //  1016:    case 0x40: {
  OPC_CheckPredicate, 41,                    //  1018:     check predicate 41
  OPC_Decode, 171, 16, 206, 1,               //  1020:     decode to MFHGC0 using decoder 206
                                             //  1020:    }
  96, 0,                                     //  1025:    case 0x60: {
  OPC_CheckPredicate, 41,                    //  1027:     check predicate 41
  OPC_Decode, 187, 17, 207, 1,               //  1029:     decode to MTHGC0 using decoder 207
                                             //  1029:    }
                                             //  1029:    } // switch Inst[10:4]
                                             //  1029:   }
  4, 11,                                     //  1034:   case 0x4: {
  OPC_CheckPredicate, 27,                    //  1036:    check predicate 27
  OPC_CheckField, 4, 7, 0,                   //  1038:    check Inst[10:4] == 0x0
  OPC_Decode, 170, 17, 207, 1,               //  1042:    decode to MTC0 using decoder 207
                                             //  1042:   }
  8, 11,                                     //  1047:   case 0x8: {
  OPC_CheckPredicate, 42,                    //  1049:    check predicate 42
  OPC_CheckField, 6, 5, 0,                   //  1051:    check Inst[10:6] == 0x0
  OPC_Decode, 185, 16, 208, 1,               //  1055:    decode to MFTR using decoder 208
                                             //  1055:   }
  11, 79,                                    //  1060:   case 0xb: {
  OPC_SwitchField, 4, 12,                    //  1062:    switch Inst[15:4] {
  0, 10,                                     //  1065:    case 0x0: {
  OPC_CheckPredicate, 42,                    //  1067:     check predicate 42
  OPC_CheckField, 0, 3, 1,                   //  1069:     check Inst[2:0] == 0x1
  OPC_Decode, 160, 12, 99,                   //  1073:     decode to DVPE using decoder 99
                                             //  1073:    }
  2, 10,                                     //  1077:    case 0x2: {
  OPC_CheckPredicate, 42,                    //  1079:     check predicate 42
  OPC_CheckField, 0, 3, 1,                   //  1081:     check Inst[2:0] == 0x1
  OPC_Decode, 177, 12, 99,                   //  1085:     decode to EVPE using decoder 99
                                             //  1085:    }
  188, 1, 10,                                //  1089:    case 0xbc: {
  OPC_CheckPredicate, 42,                    //  1092:     check predicate 42
  OPC_CheckField, 0, 3, 1,                   //  1094:     check Inst[2:0] == 0x1
  OPC_Decode, 204, 11, 99,                   //  1098:     decode to DMT using decoder 99
                                             //  1098:    }
  190, 1, 10,                                //  1102:    case 0xbe: {
  OPC_CheckPredicate, 42,                    //  1105:     check predicate 42
  OPC_CheckField, 0, 3, 1,                   //  1107:     check Inst[2:0] == 0x1
  OPC_Decode, 170, 12, 99,                   //  1111:     decode to EMT using decoder 99
                                             //  1111:    }
  128, 12, 10,                               //  1115:    case 0x600: {
  OPC_CheckPredicate, 28,                    //  1118:     check predicate 28
  OPC_CheckField, 0, 3, 0,                   //  1120:     check Inst[2:0] == 0x0
  OPC_Decode, 177, 11, 99,                   //  1124:     decode to DI using decoder 99
                                             //  1124:    }
  130, 12, 0,                                //  1128:    case 0x602: {
  OPC_CheckPredicate, 28,                    //  1131:     check predicate 28
  OPC_CheckField, 0, 3, 0,                   //  1133:     check Inst[2:0] == 0x0
  OPC_Decode, 167, 12, 99,                   //  1137:     decode to EI using decoder 99
                                             //  1137:    }
                                             //  1137:    } // switch Inst[15:4]
                                             //  1137:   }
  12, 11,                                    //  1141:   case 0xc: {
  OPC_CheckPredicate, 42,                    //  1143:    check predicate 42
  OPC_CheckField, 6, 5, 0,                   //  1145:    check Inst[10:6] == 0x0
  OPC_Decode, 207, 17, 208, 1,               //  1149:    decode to MTTR using decoder 208
                                             //  1149:   }
  16, 0,                                     //  1154:   case 0x10: {
  OPC_SwitchField, 0, 3,                     //  1156:    switch Inst[2:0] {
  0, 19,                                     //  1159:    case 0x0: {
  OPC_SwitchField, 4, 17,                    //  1161:     switch Inst[20:4] {
  1, 6,                                      //  1164:     case 0x1: {
  OPC_CheckPredicate, 41,                    //  1166:      check predicate 41
  OPC_Decode, 157, 22, 10,                   //  1168:      decode to TLBGP using decoder 10
                                             //  1168:     }
  2, 0,                                      //  1172:     case 0x2: {
  OPC_CheckPredicate, 43,                    //  1174:      check predicate 43
  OPC_Decode, 209, 22, 10,                   //  1176:      decode to WAIT using decoder 10
                                             //  1176:     }
                                             //  1176:     } // switch Inst[20:4]
                                             //  1176:    }
  1, 10,                                     //  1180:    case 0x1: {
  OPC_CheckPredicate, 27,                    //  1182:     check predicate 27
  OPC_CheckField, 4, 17, 0,                  //  1184:     check Inst[20:4] == 0x0
  OPC_Decode, 171, 22, 10,                   //  1188:     decode to TLBR using decoder 10
                                             //  1188:    }
  2, 10,                                     //  1192:    case 0x2: {
  OPC_CheckPredicate, 27,                    //  1194:     check predicate 27
  OPC_CheckField, 4, 17, 0,                  //  1196:     check Inst[20:4] == 0x0
  OPC_Decode, 173, 22, 10,                   //  1200:     decode to TLBWI using decoder 10
                                             //  1200:    }
  3, 10,                                     //  1204:    case 0x3: {
  OPC_CheckPredicate, 44,                    //  1206:     check predicate 44
  OPC_CheckField, 4, 17, 0,                  //  1208:     check Inst[20:4] == 0x0
  OPC_Decode, 165, 22, 10,                   //  1212:     decode to TLBINV using decoder 10
                                             //  1212:    }
  4, 10,                                     //  1216:    case 0x4: {
  OPC_CheckPredicate, 44,                    //  1218:     check predicate 44
  OPC_CheckField, 4, 17, 0,                  //  1220:     check Inst[20:4] == 0x0
  OPC_Decode, 166, 22, 10,                   //  1224:     decode to TLBINVF using decoder 10
                                             //  1224:    }
  6, 0,                                      //  1228:    case 0x6: {
  OPC_CheckPredicate, 27,                    //  1230:     check predicate 27
  OPC_CheckField, 4, 17, 0,                  //  1232:     check Inst[20:4] == 0x0
  OPC_Decode, 175, 22, 10,                   //  1236:     decode to TLBWR using decoder 10
                                             //  1236:    }
                                             //  1236:    } // switch Inst[2:0]
                                             //  1236:   }
                                             //  1236:   } // switch Inst[25:21]
                                             //  1236:  }
  1, 0,                                      //  1240:  case 0x1: {
  OPC_SwitchField, 0, 3,                     //  1242:   switch Inst[2:0] {
  0, 55,                                     //  1245:   case 0x0: {
  OPC_SwitchField, 4, 2,                     //  1247:    switch Inst[5:4] {
  0, 12,                                     //  1250:    case 0x0: {
  OPC_CheckPredicate, 27,                    //  1252:     check predicate 27
  OPC_CheckField, 6, 20, 128, 128, 32,       //  1254:     check Inst[25:6] == 0x80000
  OPC_Decode, 169, 22, 10,                   //  1260:     decode to TLBP using decoder 10
                                             //  1260:    }
  1, 23,                                     //  1264:    case 0x1: {
  OPC_SwitchField, 6, 20,                    //  1266:     switch Inst[25:6] {
  128, 128, 32, 6,                           //  1269:     case 0x80000: {
  OPC_CheckPredicate, 43,                    //  1273:      check predicate 43
  OPC_Decode, 171, 12, 10,                   //  1275:      decode to ERET using decoder 10
                                             //  1275:     }
  129, 128, 32, 0,                           //  1279:     case 0x80001: {
  OPC_CheckPredicate, 45,                    //  1283:      check predicate 45
  OPC_Decode, 172, 12, 10,                   //  1285:      decode to ERETNC using decoder 10
                                             //  1285:     }
                                             //  1285:     } // switch Inst[25:6]
                                             //  1285:    }
  2, 0,                                      //  1289:    case 0x2: {
  OPC_CheckPredicate, 41,                    //  1291:     check predicate 41
  OPC_CheckField, 25, 1, 1,                  //  1293:     check Inst[25] == 0x1
  OPC_Decode, 149, 14, 209, 1,               //  1297:     decode to HYPCALL using decoder 209
                                             //  1297:    }
                                             //  1297:    } // switch Inst[5:4]
                                             //  1297:   }
  1, 13,                                     //  1302:   case 0x1: {
  OPC_CheckPredicate, 41,                    //  1304:    check predicate 41
  OPC_CheckField, 4, 22, 128, 128, 128, 1,   //  1306:    check Inst[25:4] == 0x200000
  OPC_Decode, 159, 22, 10,                   //  1313:    decode to TLBGR using decoder 10
                                             //  1313:   }
  2, 13,                                     //  1317:   case 0x2: {
  OPC_CheckPredicate, 41,                    //  1319:    check predicate 41
  OPC_CheckField, 4, 22, 128, 128, 128, 1,   //  1321:    check Inst[25:4] == 0x200000
  OPC_Decode, 161, 22, 10,                   //  1328:    decode to TLBGWI using decoder 10
                                             //  1328:   }
  3, 13,                                     //  1332:   case 0x3: {
  OPC_CheckPredicate, 41,                    //  1334:    check predicate 41
  OPC_CheckField, 4, 22, 128, 128, 128, 1,   //  1336:    check Inst[25:4] == 0x200000
  OPC_Decode, 153, 22, 10,                   //  1343:    decode to TLBGINV using decoder 10
                                             //  1343:   }
  4, 13,                                     //  1347:   case 0x4: {
  OPC_CheckPredicate, 41,                    //  1349:    check predicate 41
  OPC_CheckField, 4, 22, 128, 128, 128, 1,   //  1351:    check Inst[25:4] == 0x200000
  OPC_Decode, 154, 22, 10,                   //  1358:    decode to TLBGINVF using decoder 10
                                             //  1358:   }
  6, 13,                                     //  1362:   case 0x6: {
  OPC_CheckPredicate, 41,                    //  1364:    check predicate 41
  OPC_CheckField, 4, 22, 128, 128, 128, 1,   //  1366:    check Inst[25:4] == 0x200000
  OPC_Decode, 163, 22, 10,                   //  1373:    decode to TLBGWR using decoder 10
                                             //  1373:   }
  7, 0,                                      //  1377:   case 0x7: {
  OPC_CheckPredicate, 46,                    //  1379:    check predicate 46
  OPC_CheckField, 4, 22, 129, 128, 128, 1,   //  1381:    check Inst[25:4] == 0x200001
  OPC_Decode, 170, 11, 10,                   //  1388:    decode to DERET using decoder 10
                                             //  1388:   }
                                             //  1388:   } // switch Inst[2:0]
                                             //  1388:  }
                                             //  1388:  } // switch Inst[3]
                                             //  1388: }
  17, 165, 9,                                //  1392: case 0x11: {
  OPC_SwitchField, 21, 5,                    //  1395:  switch Inst[25:21] {
  0, 11,                                     //  1398:  case 0x0: {
  OPC_CheckPredicate, 47,                    //  1400:   check predicate 47
  OPC_CheckField, 0, 11, 0,                  //  1402:   check Inst[10:0] == 0x0
  OPC_Decode, 157, 16, 210, 1,               //  1406:   decode to MFC1 using decoder 210
                                             //  1406:  }
  1, 11,                                     //  1411:  case 0x1: {
  OPC_CheckPredicate, 48,                    //  1413:   check predicate 48
  OPC_CheckField, 0, 11, 0,                  //  1415:   check Inst[10:0] == 0x0
  OPC_Decode, 198, 11, 211, 1,               //  1419:   decode to DMFC1 using decoder 211
                                             //  1419:  }
  2, 11,                                     //  1424:  case 0x2: {
  OPC_CheckPredicate, 47,                    //  1426:   check predicate 47
  OPC_CheckField, 0, 11, 0,                  //  1428:   check Inst[10:0] == 0x0
  OPC_Decode, 244, 8, 212, 1,                //  1432:   decode to CFC1 using decoder 212
                                             //  1432:  }
  3, 11,                                     //  1437:  case 0x3: {
  OPC_CheckPredicate, 49,                    //  1439:   check predicate 49
  OPC_CheckField, 0, 11, 0,                  //  1441:   check Inst[10:0] == 0x0
  OPC_Decode, 166, 16, 213, 1,               //  1445:   decode to MFHC1_D32 using decoder 213
                                             //  1445:  }
  4, 11,                                     //  1450:  case 0x4: {
  OPC_CheckPredicate, 47,                    //  1452:   check predicate 47
  OPC_CheckField, 0, 11, 0,                  //  1454:   check Inst[10:0] == 0x0
  OPC_Decode, 172, 17, 214, 1,               //  1458:   decode to MTC1 using decoder 214
                                             //  1458:  }
  5, 11,                                     //  1463:  case 0x5: {
  OPC_CheckPredicate, 48,                    //  1465:   check predicate 48
  OPC_CheckField, 0, 11, 0,                  //  1467:   check Inst[10:0] == 0x0
  OPC_Decode, 206, 11, 215, 1,               //  1471:   decode to DMTC1 using decoder 215
                                             //  1471:  }
  6, 11,                                     //  1476:  case 0x6: {
  OPC_CheckPredicate, 47,                    //  1478:   check predicate 47
  OPC_CheckField, 0, 11, 0,                  //  1480:   check Inst[10:0] == 0x0
  OPC_Decode, 143, 10, 216, 1,               //  1484:   decode to CTC1 using decoder 216
                                             //  1484:  }
  7, 11,                                     //  1489:  case 0x7: {
  OPC_CheckPredicate, 49,                    //  1491:   check predicate 49
  OPC_CheckField, 0, 11, 0,                  //  1493:   check Inst[10:0] == 0x0
  OPC_Decode, 182, 17, 217, 1,               //  1497:   decode to MTHC1_D32 using decoder 217
                                             //  1497:  }
  8, 39,                                     //  1502:  case 0x8: {
  OPC_SwitchField, 16, 2,                    //  1504:   switch Inst[17:16] {
  0, 7,                                      //  1507:   case 0x0: {
  OPC_CheckPredicate, 50,                    //  1509:    check predicate 50
  OPC_Decode, 165, 7, 218, 1,                //  1511:    decode to BC1F using decoder 218
                                             //  1511:   }
  1, 7,                                      //  1516:   case 0x1: {
  OPC_CheckPredicate, 50,                    //  1518:    check predicate 50
  OPC_Decode, 170, 7, 218, 1,                //  1520:    decode to BC1T using decoder 218
                                             //  1520:   }
  2, 7,                                      //  1525:   case 0x2: {
  OPC_CheckPredicate, 51,                    //  1527:    check predicate 51
  OPC_Decode, 166, 7, 218, 1,                //  1529:    decode to BC1FL using decoder 218
                                             //  1529:   }
  3, 0,                                      //  1534:   case 0x3: {
  OPC_CheckPredicate, 51,                    //  1536:    check predicate 51
  OPC_Decode, 171, 7, 218, 1,                //  1538:    decode to BC1TL using decoder 218
                                             //  1538:   }
                                             //  1538:   } // switch Inst[17:16]
                                             //  1538:  }
  11, 7,                                     //  1543:  case 0xb: {
  OPC_CheckPredicate, 30,                    //  1545:   check predicate 30
  OPC_Decode, 206, 8, 219, 1,                //  1547:   decode to BZ_V using decoder 219
                                             //  1547:  }
  15, 7,                                     //  1552:  case 0xf: {
  OPC_CheckPredicate, 30,                    //  1554:   check predicate 30
  OPC_Decode, 181, 8, 219, 1,                //  1556:   decode to BNZ_V using decoder 219
                                             //  1556:  }
  16, 201, 3,                                //  1561:  case 0x10: {
  OPC_SwitchField, 0, 6,                     //  1564:   switch Inst[5:0] {
  0, 7,                                      //  1567:   case 0x0: {
  OPC_CheckPredicate, 47,                    //  1569:    check predicate 47
  OPC_Decode, 220, 12, 220, 1,               //  1571:    decode to FADD_S using decoder 220
                                             //  1571:   }
  1, 7,                                      //  1576:   case 0x1: {
  OPC_CheckPredicate, 47,                    //  1578:    check predicate 47
  OPC_Decode, 237, 13, 220, 1,               //  1580:    decode to FSUB_S using decoder 220
                                             //  1580:   }
  2, 7,                                      //  1585:   case 0x2: {
  OPC_CheckPredicate, 47,                    //  1587:    check predicate 47
  OPC_Decode, 193, 13, 220, 1,               //  1589:    decode to FMUL_S using decoder 220
                                             //  1589:   }
  3, 7,                                      //  1594:   case 0x3: {
  OPC_CheckPredicate, 47,                    //  1596:    check predicate 47
  OPC_Decode, 130, 13, 220, 1,               //  1598:    decode to FDIV_S using decoder 220
                                             //  1598:   }
  4, 11,                                     //  1603:   case 0x4: {
  OPC_CheckPredicate, 52,                    //  1605:    check predicate 52
  OPC_CheckField, 16, 5, 0,                  //  1607:    check Inst[20:16] == 0x0
  OPC_Decode, 228, 13, 221, 1,               //  1611:    decode to FSQRT_S using decoder 221
                                             //  1611:   }
  5, 11,                                     //  1616:   case 0x5: {
  OPC_CheckPredicate, 47,                    //  1618:    check predicate 47
  OPC_CheckField, 16, 5, 0,                  //  1620:    check Inst[20:16] == 0x0
  OPC_Decode, 212, 12, 221, 1,               //  1624:    decode to FABS_S using decoder 221
                                             //  1624:   }
  6, 11,                                     //  1629:   case 0x6: {
  OPC_CheckPredicate, 47,                    //  1631:    check predicate 47
  OPC_CheckField, 16, 5, 0,                  //  1633:    check Inst[20:16] == 0x0
  OPC_Decode, 182, 13, 221, 1,               //  1637:    decode to FMOV_S using decoder 221
                                             //  1637:   }
  7, 11,                                     //  1642:   case 0x7: {
  OPC_CheckPredicate, 53,                    //  1644:    check predicate 53
  OPC_CheckField, 16, 5, 0,                  //  1646:    check Inst[20:16] == 0x0
  OPC_Decode, 201, 13, 221, 1,               //  1650:    decode to FNEG_S using decoder 221
                                             //  1650:   }
  12, 11,                                    //  1655:   case 0xc: {
  OPC_CheckPredicate, 52,                    //  1657:    check predicate 52
  OPC_CheckField, 16, 5, 0,                  //  1659:    check Inst[20:16] == 0x0
  OPC_Decode, 157, 19, 221, 1,               //  1663:    decode to ROUND_W_S using decoder 221
                                             //  1663:   }
  13, 11,                                    //  1668:   case 0xd: {
  OPC_CheckPredicate, 52,                    //  1670:    check predicate 52
  OPC_CheckField, 16, 5, 0,                  //  1672:    check Inst[20:16] == 0x0
  OPC_Decode, 196, 22, 221, 1,               //  1676:    decode to TRUNC_W_S using decoder 221
                                             //  1676:   }
  14, 11,                                    //  1681:   case 0xe: {
  OPC_CheckPredicate, 52,                    //  1683:    check predicate 52
  OPC_CheckField, 16, 5, 0,                  //  1685:    check Inst[20:16] == 0x0
  OPC_Decode, 233, 8, 221, 1,                //  1689:    decode to CEIL_W_S using decoder 221
                                             //  1689:   }
  15, 11,                                    //  1694:   case 0xf: {
  OPC_CheckPredicate, 52,                    //  1696:    check predicate 52
  OPC_CheckField, 16, 5, 0,                  //  1698:    check Inst[20:16] == 0x0
  OPC_Decode, 164, 13, 221, 1,               //  1702:    decode to FLOOR_W_S using decoder 221
                                             //  1702:   }
  17, 21,                                    //  1707:   case 0x11: {
  OPC_SwitchField, 16, 2,                    //  1709:    switch Inst[17:16] {
  0, 7,                                      //  1712:    case 0x0: {
  OPC_CheckPredicate, 29,                    //  1714:     check predicate 29
  OPC_Decode, 239, 16, 222, 1,               //  1716:     decode to MOVF_S using decoder 222
                                             //  1716:    }
  1, 0,                                      //  1721:    case 0x1: {
  OPC_CheckPredicate, 29,                    //  1723:     check predicate 29
  OPC_Decode, 131, 17, 222, 1,               //  1725:     decode to MOVT_S using decoder 222
                                             //  1725:    }
                                             //  1725:    } // switch Inst[17:16]
                                             //  1725:   }
  18, 7,                                     //  1730:   case 0x12: {
  OPC_CheckPredicate, 29,                    //  1732:    check predicate 29
  OPC_Decode, 143, 17, 223, 1,               //  1734:    decode to MOVZ_I_S using decoder 223
                                             //  1734:   }
  19, 7,                                     //  1739:   case 0x13: {
  OPC_CheckPredicate, 29,                    //  1741:    check predicate 29
  OPC_Decode, 251, 16, 223, 1,               //  1743:    decode to MOVN_I_S using decoder 223
                                             //  1743:   }
  21, 11,                                    //  1748:   case 0x15: {
  OPC_CheckPredicate, 54,                    //  1750:    check predicate 54
  OPC_CheckField, 16, 5, 0,                  //  1752:    check Inst[20:16] == 0x0
  OPC_Decode, 131, 19, 221, 1,               //  1756:    decode to RECIP_S using decoder 221
                                             //  1756:   }
  22, 11,                                    //  1761:   case 0x16: {
  OPC_CheckPredicate, 54,                    //  1763:    check predicate 54
  OPC_CheckField, 16, 5, 0,                  //  1765:    check Inst[20:16] == 0x0
  OPC_Decode, 164, 19, 221, 1,               //  1769:    decode to RSQRT_S using decoder 221
                                             //  1769:   }
  33, 11,                                    //  1774:   case 0x21: {
  OPC_CheckPredicate, 55,                    //  1776:    check predicate 55
  OPC_CheckField, 16, 5, 0,                  //  1778:    check Inst[20:16] == 0x0
  OPC_Decode, 147, 10, 224, 1,               //  1782:    decode to CVT_D32_S using decoder 224
                                             //  1782:   }
  36, 11,                                    //  1787:   case 0x24: {
  OPC_CheckPredicate, 47,                    //  1789:    check predicate 47
  OPC_CheckField, 16, 5, 0,                  //  1791:    check Inst[20:16] == 0x0
  OPC_Decode, 181, 10, 221, 1,               //  1795:    decode to CVT_W_S using decoder 221
                                             //  1795:   }
  37, 11,                                    //  1800:   case 0x25: {
  OPC_CheckPredicate, 56,                    //  1802:    check predicate 56
  OPC_CheckField, 16, 5, 0,                  //  1804:    check Inst[20:16] == 0x0
  OPC_Decode, 160, 10, 225, 1,               //  1808:    decode to CVT_L_S using decoder 225
                                             //  1808:   }
  48, 11,                                    //  1813:   case 0x30: {
  OPC_CheckPredicate, 50,                    //  1815:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1817:    check Inst[7:6] == 0x0
  OPC_Decode, 194, 10, 226, 1,               //  1821:    decode to C_F_S using decoder 226
                                             //  1821:   }
  49, 11,                                    //  1826:   case 0x31: {
  OPC_CheckPredicate, 50,                    //  1828:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1830:    check Inst[7:6] == 0x0
  OPC_Decode, 150, 11, 226, 1,               //  1834:    decode to C_UN_S using decoder 226
                                             //  1834:   }
  50, 11,                                    //  1839:   case 0x32: {
  OPC_CheckPredicate, 50,                    //  1841:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1843:    check Inst[7:6] == 0x0
  OPC_Decode, 188, 10, 226, 1,               //  1847:    decode to C_EQ_S using decoder 226
                                             //  1847:   }
  51, 11,                                    //  1852:   case 0x33: {
  OPC_CheckPredicate, 50,                    //  1854:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1856:    check Inst[7:6] == 0x0
  OPC_Decode, 132, 11, 226, 1,               //  1860:    decode to C_UEQ_S using decoder 226
                                             //  1860:   }
  52, 11,                                    //  1865:   case 0x34: {
  OPC_CheckPredicate, 50,                    //  1867:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1869:    check Inst[7:6] == 0x0
  OPC_Decode, 242, 10, 226, 1,               //  1873:    decode to C_OLT_S using decoder 226
                                             //  1873:   }
  53, 11,                                    //  1878:   case 0x35: {
  OPC_CheckPredicate, 50,                    //  1880:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1882:    check Inst[7:6] == 0x0
  OPC_Decode, 144, 11, 226, 1,               //  1886:    decode to C_ULT_S using decoder 226
                                             //  1886:   }
  54, 11,                                    //  1891:   case 0x36: {
  OPC_CheckPredicate, 50,                    //  1893:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1895:    check Inst[7:6] == 0x0
  OPC_Decode, 236, 10, 226, 1,               //  1899:    decode to C_OLE_S using decoder 226
                                             //  1899:   }
  55, 11,                                    //  1904:   case 0x37: {
  OPC_CheckPredicate, 50,                    //  1906:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1908:    check Inst[7:6] == 0x0
  OPC_Decode, 138, 11, 226, 1,               //  1912:    decode to C_ULE_S using decoder 226
                                             //  1912:   }
  56, 11,                                    //  1917:   case 0x38: {
  OPC_CheckPredicate, 50,                    //  1919:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1921:    check Inst[7:6] == 0x0
  OPC_Decode, 254, 10, 226, 1,               //  1925:    decode to C_SF_S using decoder 226
                                             //  1925:   }
  57, 11,                                    //  1930:   case 0x39: {
  OPC_CheckPredicate, 50,                    //  1932:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1934:    check Inst[7:6] == 0x0
  OPC_Decode, 218, 10, 226, 1,               //  1938:    decode to C_NGLE_S using decoder 226
                                             //  1938:   }
  58, 11,                                    //  1943:   case 0x3a: {
  OPC_CheckPredicate, 50,                    //  1945:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1947:    check Inst[7:6] == 0x0
  OPC_Decode, 248, 10, 226, 1,               //  1951:    decode to C_SEQ_S using decoder 226
                                             //  1951:   }
  59, 11,                                    //  1956:   case 0x3b: {
  OPC_CheckPredicate, 50,                    //  1958:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1960:    check Inst[7:6] == 0x0
  OPC_Decode, 224, 10, 226, 1,               //  1964:    decode to C_NGL_S using decoder 226
                                             //  1964:   }
  60, 11,                                    //  1969:   case 0x3c: {
  OPC_CheckPredicate, 50,                    //  1971:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1973:    check Inst[7:6] == 0x0
  OPC_Decode, 206, 10, 226, 1,               //  1977:    decode to C_LT_S using decoder 226
                                             //  1977:   }
  61, 11,                                    //  1982:   case 0x3d: {
  OPC_CheckPredicate, 50,                    //  1984:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1986:    check Inst[7:6] == 0x0
  OPC_Decode, 212, 10, 226, 1,               //  1990:    decode to C_NGE_S using decoder 226
                                             //  1990:   }
  62, 11,                                    //  1995:   case 0x3e: {
  OPC_CheckPredicate, 50,                    //  1997:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  1999:    check Inst[7:6] == 0x0
  OPC_Decode, 200, 10, 226, 1,               //  2003:    decode to C_LE_S using decoder 226
                                             //  2003:   }
  63, 0,                                     //  2008:   case 0x3f: {
  OPC_CheckPredicate, 50,                    //  2010:    check predicate 50
  OPC_CheckField, 6, 2, 0,                   //  2012:    check Inst[7:6] == 0x0
  OPC_Decode, 230, 10, 226, 1,               //  2016:    decode to C_NGT_S using decoder 226
                                             //  2016:   }
                                             //  2016:   } // switch Inst[5:0]
                                             //  2016:  }
  17, 201, 3,                                //  2021:  case 0x11: {
  OPC_SwitchField, 0, 6,                     //  2024:   switch Inst[5:0] {
  0, 7,                                      //  2027:   case 0x0: {
  OPC_CheckPredicate, 55,                    //  2029:    check predicate 55
  OPC_Decode, 215, 12, 227, 1,               //  2031:    decode to FADD_D32 using decoder 227
                                             //  2031:   }
  1, 7,                                      //  2036:   case 0x1: {
  OPC_CheckPredicate, 55,                    //  2038:    check predicate 55
  OPC_Decode, 232, 13, 227, 1,               //  2040:    decode to FSUB_D32 using decoder 227
                                             //  2040:   }
  2, 7,                                      //  2045:   case 0x2: {
  OPC_CheckPredicate, 55,                    //  2047:    check predicate 55
  OPC_Decode, 188, 13, 227, 1,               //  2049:    decode to FMUL_D32 using decoder 227
                                             //  2049:   }
  3, 7,                                      //  2054:   case 0x3: {
  OPC_CheckPredicate, 55,                    //  2056:    check predicate 55
  OPC_Decode, 254, 12, 227, 1,               //  2058:    decode to FDIV_D32 using decoder 227
                                             //  2058:   }
  4, 11,                                     //  2063:   case 0x4: {
  OPC_CheckPredicate, 57,                    //  2065:    check predicate 57
  OPC_CheckField, 16, 5, 0,                  //  2067:    check Inst[20:16] == 0x0
  OPC_Decode, 224, 13, 228, 1,               //  2071:    decode to FSQRT_D32 using decoder 228
                                             //  2071:   }
  5, 11,                                     //  2076:   case 0x5: {
  OPC_CheckPredicate, 55,                    //  2078:    check predicate 55
  OPC_CheckField, 16, 5, 0,                  //  2080:    check Inst[20:16] == 0x0
  OPC_Decode, 208, 12, 228, 1,               //  2084:    decode to FABS_D32 using decoder 228
                                             //  2084:   }
  6, 11,                                     //  2089:   case 0x6: {
  OPC_CheckPredicate, 55,                    //  2091:    check predicate 55
  OPC_CheckField, 16, 5, 0,                  //  2093:    check Inst[20:16] == 0x0
  OPC_Decode, 177, 13, 228, 1,               //  2097:    decode to FMOV_D32 using decoder 228
                                             //  2097:   }
  7, 11,                                     //  2102:   case 0x7: {
  OPC_CheckPredicate, 55,                    //  2104:    check predicate 55
  OPC_CheckField, 16, 5, 0,                  //  2106:    check Inst[20:16] == 0x0
  OPC_Decode, 197, 13, 228, 1,               //  2110:    decode to FNEG_D32 using decoder 228
                                             //  2110:   }
  12, 11,                                    //  2115:   case 0xc: {
  OPC_CheckPredicate, 57,                    //  2117:    check predicate 57
  OPC_CheckField, 16, 5, 0,                  //  2119:    check Inst[20:16] == 0x0
  OPC_Decode, 153, 19, 229, 1,               //  2123:    decode to ROUND_W_D32 using decoder 229
                                             //  2123:   }
  13, 11,                                    //  2128:   case 0xd: {
  OPC_CheckPredicate, 57,                    //  2130:    check predicate 57
  OPC_CheckField, 16, 5, 0,                  //  2132:    check Inst[20:16] == 0x0
  OPC_Decode, 192, 22, 229, 1,               //  2136:    decode to TRUNC_W_D32 using decoder 229
                                             //  2136:   }
  14, 11,                                    //  2141:   case 0xe: {
  OPC_CheckPredicate, 57,                    //  2143:    check predicate 57
  OPC_CheckField, 16, 5, 0,                  //  2145:    check Inst[20:16] == 0x0
  OPC_Decode, 229, 8, 229, 1,                //  2149:    decode to CEIL_W_D32 using decoder 229
                                             //  2149:   }
  15, 11,                                    //  2154:   case 0xf: {
  OPC_CheckPredicate, 57,                    //  2156:    check predicate 57
  OPC_CheckField, 16, 5, 0,                  //  2158:    check Inst[20:16] == 0x0
  OPC_Decode, 160, 13, 229, 1,               //  2162:    decode to FLOOR_W_D32 using decoder 229
                                             //  2162:   }
  17, 21,                                    //  2167:   case 0x11: {
  OPC_SwitchField, 16, 2,                    //  2169:    switch Inst[17:16] {
  0, 7,                                      //  2172:    case 0x0: {
  OPC_CheckPredicate, 58,                    //  2174:     check predicate 58
  OPC_Decode, 233, 16, 230, 1,               //  2176:     decode to MOVF_D32 using decoder 230
                                             //  2176:    }
  1, 0,                                      //  2181:    case 0x1: {
  OPC_CheckPredicate, 58,                    //  2183:     check predicate 58
  OPC_Decode, 253, 16, 230, 1,               //  2185:     decode to MOVT_D32 using decoder 230
                                             //  2185:    }
                                             //  2185:    } // switch Inst[17:16]
                                             //  2185:   }
  18, 7,                                     //  2190:   case 0x12: {
  OPC_CheckPredicate, 58,                    //  2192:    check predicate 58
  OPC_Decode, 137, 17, 231, 1,               //  2194:    decode to MOVZ_I_D32 using decoder 231
                                             //  2194:   }
  19, 7,                                     //  2199:   case 0x13: {
  OPC_CheckPredicate, 58,                    //  2201:    check predicate 58
  OPC_Decode, 245, 16, 231, 1,               //  2203:    decode to MOVN_I_D32 using decoder 231
                                             //  2203:   }
  21, 11,                                    //  2208:   case 0x15: {
  OPC_CheckPredicate, 59,                    //  2210:    check predicate 59
  OPC_CheckField, 16, 5, 0,                  //  2212:    check Inst[20:16] == 0x0
  OPC_Decode, 255, 18, 228, 1,               //  2216:    decode to RECIP_D32 using decoder 228
                                             //  2216:   }
  22, 11,                                    //  2221:   case 0x16: {
  OPC_CheckPredicate, 59,                    //  2223:    check predicate 59
  OPC_CheckField, 16, 5, 0,                  //  2225:    check Inst[20:16] == 0x0
  OPC_Decode, 160, 19, 228, 1,               //  2229:    decode to RSQRT_D32 using decoder 228
                                             //  2229:   }
  32, 11,                                    //  2234:   case 0x20: {
  OPC_CheckPredicate, 55,                    //  2236:    check predicate 55
  OPC_CheckField, 16, 5, 0,                  //  2238:    check Inst[20:16] == 0x0
  OPC_Decode, 166, 10, 229, 1,               //  2242:    decode to CVT_S_D32 using decoder 229
                                             //  2242:   }
  36, 11,                                    //  2247:   case 0x24: {
  OPC_CheckPredicate, 55,                    //  2249:    check predicate 55
  OPC_CheckField, 16, 5, 0,                  //  2251:    check Inst[20:16] == 0x0
  OPC_Decode, 177, 10, 229, 1,               //  2255:    decode to CVT_W_D32 using decoder 229
                                             //  2255:   }
  37, 11,                                    //  2260:   case 0x25: {
  OPC_CheckPredicate, 56,                    //  2262:    check predicate 56
  OPC_CheckField, 16, 5, 0,                  //  2264:    check Inst[20:16] == 0x0
  OPC_Decode, 157, 10, 232, 1,               //  2268:    decode to CVT_L_D64 using decoder 232
                                             //  2268:   }
  48, 11,                                    //  2273:   case 0x30: {
  OPC_CheckPredicate, 60,                    //  2275:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2277:    check Inst[7:6] == 0x0
  OPC_Decode, 190, 10, 233, 1,               //  2281:    decode to C_F_D32 using decoder 233
                                             //  2281:   }
  49, 11,                                    //  2286:   case 0x31: {
  OPC_CheckPredicate, 60,                    //  2288:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2290:    check Inst[7:6] == 0x0
  OPC_Decode, 146, 11, 233, 1,               //  2294:    decode to C_UN_D32 using decoder 233
                                             //  2294:   }
  50, 11,                                    //  2299:   case 0x32: {
  OPC_CheckPredicate, 60,                    //  2301:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2303:    check Inst[7:6] == 0x0
  OPC_Decode, 184, 10, 233, 1,               //  2307:    decode to C_EQ_D32 using decoder 233
                                             //  2307:   }
  51, 11,                                    //  2312:   case 0x33: {
  OPC_CheckPredicate, 60,                    //  2314:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2316:    check Inst[7:6] == 0x0
  OPC_Decode, 128, 11, 233, 1,               //  2320:    decode to C_UEQ_D32 using decoder 233
                                             //  2320:   }
  52, 11,                                    //  2325:   case 0x34: {
  OPC_CheckPredicate, 60,                    //  2327:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2329:    check Inst[7:6] == 0x0
  OPC_Decode, 238, 10, 233, 1,               //  2333:    decode to C_OLT_D32 using decoder 233
                                             //  2333:   }
  53, 11,                                    //  2338:   case 0x35: {
  OPC_CheckPredicate, 60,                    //  2340:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2342:    check Inst[7:6] == 0x0
  OPC_Decode, 140, 11, 233, 1,               //  2346:    decode to C_ULT_D32 using decoder 233
                                             //  2346:   }
  54, 11,                                    //  2351:   case 0x36: {
  OPC_CheckPredicate, 60,                    //  2353:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2355:    check Inst[7:6] == 0x0
  OPC_Decode, 232, 10, 233, 1,               //  2359:    decode to C_OLE_D32 using decoder 233
                                             //  2359:   }
  55, 11,                                    //  2364:   case 0x37: {
  OPC_CheckPredicate, 60,                    //  2366:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2368:    check Inst[7:6] == 0x0
  OPC_Decode, 134, 11, 233, 1,               //  2372:    decode to C_ULE_D32 using decoder 233
                                             //  2372:   }
  56, 11,                                    //  2377:   case 0x38: {
  OPC_CheckPredicate, 60,                    //  2379:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2381:    check Inst[7:6] == 0x0
  OPC_Decode, 250, 10, 233, 1,               //  2385:    decode to C_SF_D32 using decoder 233
                                             //  2385:   }
  57, 11,                                    //  2390:   case 0x39: {
  OPC_CheckPredicate, 60,                    //  2392:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2394:    check Inst[7:6] == 0x0
  OPC_Decode, 214, 10, 233, 1,               //  2398:    decode to C_NGLE_D32 using decoder 233
                                             //  2398:   }
  58, 11,                                    //  2403:   case 0x3a: {
  OPC_CheckPredicate, 60,                    //  2405:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2407:    check Inst[7:6] == 0x0
  OPC_Decode, 244, 10, 233, 1,               //  2411:    decode to C_SEQ_D32 using decoder 233
                                             //  2411:   }
  59, 11,                                    //  2416:   case 0x3b: {
  OPC_CheckPredicate, 60,                    //  2418:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2420:    check Inst[7:6] == 0x0
  OPC_Decode, 220, 10, 233, 1,               //  2424:    decode to C_NGL_D32 using decoder 233
                                             //  2424:   }
  60, 11,                                    //  2429:   case 0x3c: {
  OPC_CheckPredicate, 60,                    //  2431:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2433:    check Inst[7:6] == 0x0
  OPC_Decode, 202, 10, 233, 1,               //  2437:    decode to C_LT_D32 using decoder 233
                                             //  2437:   }
  61, 11,                                    //  2442:   case 0x3d: {
  OPC_CheckPredicate, 60,                    //  2444:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2446:    check Inst[7:6] == 0x0
  OPC_Decode, 208, 10, 233, 1,               //  2450:    decode to C_NGE_D32 using decoder 233
                                             //  2450:   }
  62, 11,                                    //  2455:   case 0x3e: {
  OPC_CheckPredicate, 60,                    //  2457:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2459:    check Inst[7:6] == 0x0
  OPC_Decode, 196, 10, 233, 1,               //  2463:    decode to C_LE_D32 using decoder 233
                                             //  2463:   }
  63, 0,                                     //  2468:   case 0x3f: {
  OPC_CheckPredicate, 60,                    //  2470:    check predicate 60
  OPC_CheckField, 6, 2, 0,                   //  2472:    check Inst[7:6] == 0x0
  OPC_Decode, 226, 10, 233, 1,               //  2476:    decode to C_NGT_D32 using decoder 233
                                             //  2476:   }
                                             //  2476:   } // switch Inst[5:0]
                                             //  2476:  }
  20, 29,                                    //  2481:  case 0x14: {
  OPC_SwitchField, 0, 6,                     //  2483:   switch Inst[5:0] {
  32, 11,                                    //  2486:   case 0x20: {
  OPC_CheckPredicate, 47,                    //  2488:    check predicate 47
  OPC_CheckField, 16, 5, 0,                  //  2490:    check Inst[20:16] == 0x0
  OPC_Decode, 174, 10, 221, 1,               //  2494:    decode to CVT_S_W using decoder 221
                                             //  2494:   }
  33, 0,                                     //  2499:   case 0x21: {
  OPC_CheckPredicate, 55,                    //  2501:    check predicate 55
  OPC_CheckField, 16, 5, 0,                  //  2503:    check Inst[20:16] == 0x0
  OPC_Decode, 149, 10, 224, 1,               //  2507:    decode to CVT_D32_W using decoder 224
                                             //  2507:   }
                                             //  2507:   } // switch Inst[5:0]
                                             //  2507:  }
  24, 7,                                     //  2512:  case 0x18: {
  OPC_CheckPredicate, 30,                    //  2514:   check predicate 30
  OPC_Decode, 203, 8, 219, 1,                //  2516:   decode to BZ_B using decoder 219
                                             //  2516:  }
  25, 7,                                     //  2521:  case 0x19: {
  OPC_CheckPredicate, 30,                    //  2523:   check predicate 30
  OPC_Decode, 205, 8, 234, 1,                //  2525:   decode to BZ_H using decoder 234
                                             //  2525:  }
  26, 7,                                     //  2530:  case 0x1a: {
  OPC_CheckPredicate, 30,                    //  2532:   check predicate 30
  OPC_Decode, 207, 8, 235, 1,                //  2534:   decode to BZ_W using decoder 235
                                             //  2534:  }
  27, 7,                                     //  2539:  case 0x1b: {
  OPC_CheckPredicate, 30,                    //  2541:   check predicate 30
  OPC_Decode, 204, 8, 236, 1,                //  2543:   decode to BZ_D using decoder 236
                                             //  2543:  }
  28, 7,                                     //  2548:  case 0x1c: {
  OPC_CheckPredicate, 30,                    //  2550:   check predicate 30
  OPC_Decode, 178, 8, 219, 1,                //  2552:   decode to BNZ_B using decoder 219
                                             //  2552:  }
  29, 7,                                     //  2557:  case 0x1d: {
  OPC_CheckPredicate, 30,                    //  2559:   check predicate 30
  OPC_Decode, 180, 8, 234, 1,                //  2561:   decode to BNZ_H using decoder 234
                                             //  2561:  }
  30, 7,                                     //  2566:  case 0x1e: {
  OPC_CheckPredicate, 30,                    //  2568:   check predicate 30
  OPC_Decode, 182, 8, 235, 1,                //  2570:   decode to BNZ_W using decoder 235
                                             //  2570:  }
  31, 0,                                     //  2575:  case 0x1f: {
  OPC_CheckPredicate, 30,                    //  2577:   check predicate 30
  OPC_Decode, 179, 8, 236, 1,                //  2579:   decode to BNZ_D using decoder 236
                                             //  2579:  }
                                             //  2579:  } // switch Inst[25:21]
                                             //  2579: }
  18, 29,                                    //  2584: case 0x12: {
  OPC_SwitchField, 21, 5,                    //  2586:  switch Inst[25:21] {
  0, 11,                                     //  2589:  case 0x0: {
  OPC_CheckPredicate, 27,                    //  2591:   check predicate 27
  OPC_CheckField, 3, 8, 0,                   //  2593:   check Inst[10:3] == 0x0
  OPC_Decode, 161, 16, 237, 1,               //  2597:   decode to MFC2 using decoder 237
                                             //  2597:  }
  4, 0,                                      //  2602:  case 0x4: {
  OPC_CheckPredicate, 27,                    //  2604:   check predicate 27
  OPC_CheckField, 3, 8, 0,                   //  2606:   check Inst[10:3] == 0x0
  OPC_Decode, 177, 17, 238, 1,               //  2610:   decode to MTC2 using decoder 238
                                             //  2610:  }
                                             //  2610:  } // switch Inst[25:21]
                                             //  2610: }
  19, 153, 1,                                //  2615: case 0x13: {
  OPC_SwitchField, 0, 6,                     //  2618:  switch Inst[5:0] {
  0, 11,                                     //  2621:  case 0x0: {
  OPC_CheckPredicate, 61,                    //  2623:   check predicate 61
  OPC_CheckField, 11, 5, 0,                  //  2625:   check Inst[15:11] == 0x0
  OPC_Decode, 204, 15, 239, 1,               //  2629:   decode to LWXC1 using decoder 239
                                             //  2629:  }
  1, 11,                                     //  2634:  case 0x1: {
  OPC_CheckPredicate, 62,                    //  2636:   check predicate 62
  OPC_CheckField, 11, 5, 0,                  //  2638:   check Inst[15:11] == 0x0
  OPC_Decode, 254, 14, 240, 1,               //  2642:   decode to LDXC1 using decoder 240
                                             //  2642:  }
  5, 11,                                     //  2647:  case 0x5: {
  OPC_CheckPredicate, 63,                    //  2649:   check predicate 63
  OPC_CheckField, 11, 5, 0,                  //  2651:   check Inst[15:11] == 0x0
  OPC_Decode, 164, 15, 240, 1,               //  2655:   decode to LUXC1 using decoder 240
                                             //  2655:  }
  8, 11,                                     //  2660:  case 0x8: {
  OPC_CheckPredicate, 61,                    //  2662:   check predicate 61
  OPC_CheckField, 6, 5, 0,                   //  2664:   check Inst[10:6] == 0x0
  OPC_Decode, 236, 21, 241, 1,               //  2668:   decode to SWXC1 using decoder 241
                                             //  2668:  }
  9, 11,                                     //  2673:  case 0x9: {
  OPC_CheckPredicate, 62,                    //  2675:   check predicate 62
  OPC_CheckField, 6, 5, 0,                   //  2677:   check Inst[10:6] == 0x0
  OPC_Decode, 216, 19, 242, 1,               //  2681:   decode to SDXC1 using decoder 242
                                             //  2681:  }
  13, 11,                                    //  2686:  case 0xd: {
  OPC_CheckPredicate, 63,                    //  2688:   check predicate 63
  OPC_CheckField, 6, 5, 0,                   //  2690:   check Inst[10:6] == 0x0
  OPC_Decode, 203, 21, 242, 1,               //  2694:   decode to SUXC1 using decoder 242
                                             //  2694:  }
  32, 7,                                     //  2699:  case 0x20: {
  OPC_CheckPredicate, 64,                    //  2701:   check predicate 64
  OPC_Decode, 245, 15, 243, 1,               //  2703:   decode to MADD_S using decoder 243
                                             //  2703:  }
  33, 7,                                     //  2708:  case 0x21: {
  OPC_CheckPredicate, 65,                    //  2710:   check predicate 65
  OPC_Decode, 237, 15, 244, 1,               //  2712:   decode to MADD_D32 using decoder 244
                                             //  2712:  }
  40, 7,                                     //  2717:  case 0x28: {
  OPC_CheckPredicate, 64,                    //  2719:   check predicate 64
  OPC_Decode, 168, 17, 243, 1,               //  2721:   decode to MSUB_S using decoder 243
                                             //  2721:  }
  41, 7,                                     //  2726:  case 0x29: {
  OPC_CheckPredicate, 65,                    //  2728:   check predicate 65
  OPC_Decode, 160, 17, 244, 1,               //  2730:   decode to MSUB_D32 using decoder 244
                                             //  2730:  }
  48, 7,                                     //  2735:  case 0x30: {
  OPC_CheckPredicate, 66,                    //  2737:   check predicate 66
  OPC_Decode, 147, 18, 243, 1,               //  2739:   decode to NMADD_S using decoder 243
                                             //  2739:  }
  49, 7,                                     //  2744:  case 0x31: {
  OPC_CheckPredicate, 67,                    //  2746:   check predicate 67
  OPC_Decode, 144, 18, 244, 1,               //  2748:   decode to NMADD_D32 using decoder 244
                                             //  2748:  }
  56, 7,                                     //  2753:  case 0x38: {
  OPC_CheckPredicate, 66,                    //  2755:   check predicate 66
  OPC_Decode, 152, 18, 243, 1,               //  2757:   decode to NMSUB_S using decoder 243
                                             //  2757:  }
  57, 0,                                     //  2762:  case 0x39: {
  OPC_CheckPredicate, 67,                    //  2764:   check predicate 67
  OPC_Decode, 149, 18, 244, 1,               //  2766:   decode to NMSUB_D32 using decoder 244
                                             //  2766:  }
                                             //  2766:  } // switch Inst[5:0]
                                             //  2766: }
  20, 7,                                     //  2771: case 0x14: {
  OPC_CheckPredicate, 39,                    //  2773:  check predicate 39
  OPC_Decode, 191, 7, 203, 1,                //  2775:  decode to BEQL using decoder 203
                                             //  2775: }
  21, 74,                                    //  2780: case 0x15: {
  OPC_Scope, 22,                             //  2782:  try {
  OPC_SwitchField, 0, 16,                    //  2784:   switch Inst[15:0] {
  123, 7,                                    //  2787:   case 0x7b: {
  OPC_CheckPredicate, 20,                    //  2789:    check predicate 20
  OPC_Decode, 183, 13, 131, 1,               //  2791:    decode to FMOV_S_MM using decoder 131
                                             //  2791:   }
  251, 22, 0,                                //  2796:   case 0xb7b: {
  OPC_CheckPredicate, 20,                    //  2799:    check predicate 20
  OPC_Decode, 202, 13, 131, 1,               //  2801:    decode to FNEG_S_MM using decoder 131
                                             //  2801:   }
                                             //  2801:   } // switch Inst[15:0]
  OPC_Scope, 41,                             //  2806:  } else try {
  OPC_SwitchField, 0, 11,                    //  2808:   switch Inst[10:0] {
  48, 7,                                     //  2811:   case 0x30: {
  OPC_CheckPredicate, 20,                    //  2813:    check predicate 20
  OPC_Decode, 221, 12, 165, 1,               //  2815:    decode to FADD_S_MM using decoder 165
                                             //  2815:   }
  112, 7,                                    //  2820:   case 0x70: {
  OPC_CheckPredicate, 20,                    //  2822:    check predicate 20
  OPC_Decode, 238, 13, 165, 1,               //  2824:    decode to FSUB_S_MM using decoder 165
                                             //  2824:   }
  176, 1, 7,                                 //  2829:   case 0xb0: {
  OPC_CheckPredicate, 20,                    //  2832:    check predicate 20
  OPC_Decode, 194, 13, 165, 1,               //  2834:    decode to FMUL_S_MM using decoder 165
                                             //  2834:   }
  240, 1, 0,                                 //  2839:   case 0xf0: {
  OPC_CheckPredicate, 20,                    //  2842:    check predicate 20
  OPC_Decode, 131, 13, 165, 1,               //  2844:    decode to FDIV_S_MM using decoder 165
                                             //  2844:   }
                                             //  2844:   } // switch Inst[10:0]
                                             //  2844:  } else try {
  OPC_CheckPredicate, 39,                    //  2849:   check predicate 39
  OPC_Decode, 166, 8, 203, 1,                //  2851:   decode to BNEL using decoder 203
                                             //  2851:  }
                                             //  2851: }
  22, 11,                                    //  2856: case 0x16: {
  OPC_CheckPredicate, 39,                    //  2858:  check predicate 39
  OPC_CheckField, 16, 5, 0,                  //  2860:  check Inst[20:16] == 0x0
  OPC_Decode, 128, 8, 199, 1,                //  2864:  decode to BLEZL using decoder 199
                                             //  2864: }
  23, 11,                                    //  2869: case 0x17: {
  OPC_CheckPredicate, 39,                    //  2871:  check predicate 39
  OPC_CheckField, 16, 5, 0,                  //  2873:  check Inst[20:16] == 0x0
  OPC_Decode, 227, 7, 199, 1,                //  2877:  decode to BGTZL using decoder 199
                                             //  2877: }
  28, 166, 1,                                //  2882: case 0x1c: {
  OPC_SwitchField, 0, 6,                     //  2885:  switch Inst[5:0] {
  0, 27,                                     //  2888:  case 0x0: {
  OPC_CheckField, 6, 5, 0,                   //  2890:   check Inst[10:6] == 0x0
  OPC_CheckField, 13, 3, 0,                  //  2894:   check Inst[15:13] == 0x0
  OPC_Scope, 10,                             //  2898:   try {
  OPC_CheckField, 11, 2, 0,                  //  2900:    check Inst[12:11] == 0x0
  OPC_CheckPredicate, 68,                    //  2904:    check predicate 68
  OPC_Decode, 222, 15, 86,                   //  2906:    decode to MADD using decoder 86
                                             //  2906:   } else try {
  OPC_CheckPredicate, 37,                    //  2910:    check predicate 37
  OPC_Decode, 240, 15, 245, 1,               //  2912:    decode to MADD_DSP using decoder 245
                                             //  2912:   }
                                             //  2912:  }
  1, 27,                                     //  2917:  case 0x1: {
  OPC_CheckField, 6, 5, 0,                   //  2919:   check Inst[10:6] == 0x0
  OPC_CheckField, 13, 3, 0,                  //  2923:   check Inst[15:13] == 0x0
  OPC_Scope, 10,                             //  2927:   try {
  OPC_CheckField, 11, 2, 0,                  //  2929:    check Inst[12:11] == 0x0
  OPC_CheckPredicate, 68,                    //  2933:    check predicate 68
  OPC_Decode, 229, 15, 86,                   //  2935:    decode to MADDU using decoder 86
                                             //  2935:   } else try {
  OPC_CheckPredicate, 37,                    //  2939:    check predicate 37
  OPC_Decode, 230, 15, 245, 1,               //  2941:    decode to MADDU_DSP using decoder 245
                                             //  2941:   }
                                             //  2941:  }
  2, 10,                                     //  2946:  case 0x2: {
  OPC_CheckPredicate, 68,                    //  2948:   check predicate 68
  OPC_CheckField, 6, 5, 0,                   //  2950:   check Inst[10:6] == 0x0
  OPC_Decode, 212, 17, 67,                   //  2954:   decode to MUL using decoder 67
                                             //  2954:  }
  4, 27,                                     //  2958:  case 0x4: {
  OPC_CheckField, 6, 5, 0,                   //  2960:   check Inst[10:6] == 0x0
  OPC_CheckField, 13, 3, 0,                  //  2964:   check Inst[15:13] == 0x0
  OPC_Scope, 10,                             //  2968:   try {
  OPC_CheckField, 11, 2, 0,                  //  2970:    check Inst[12:11] == 0x0
  OPC_CheckPredicate, 68,                    //  2974:    check predicate 68
  OPC_Decode, 145, 17, 86,                   //  2976:    decode to MSUB using decoder 86
                                             //  2976:   } else try {
  OPC_CheckPredicate, 37,                    //  2980:    check predicate 37
  OPC_Decode, 163, 17, 245, 1,               //  2982:    decode to MSUB_DSP using decoder 245
                                             //  2982:   }
                                             //  2982:  }
  5, 27,                                     //  2987:  case 0x5: {
  OPC_CheckField, 6, 5, 0,                   //  2989:   check Inst[10:6] == 0x0
  OPC_CheckField, 13, 3, 0,                  //  2993:   check Inst[15:13] == 0x0
  OPC_Scope, 10,                             //  2997:   try {
  OPC_CheckField, 11, 2, 0,                  //  2999:    check Inst[12:11] == 0x0
  OPC_CheckPredicate, 68,                    //  3003:    check predicate 68
  OPC_Decode, 152, 17, 86,                   //  3005:    decode to MSUBU using decoder 86
                                             //  3005:   } else try {
  OPC_CheckPredicate, 37,                    //  3009:    check predicate 37
  OPC_Decode, 153, 17, 245, 1,               //  3011:    decode to MSUBU_DSP using decoder 245
                                             //  3011:   }
                                             //  3011:  }
  32, 11,                                    //  3016:  case 0x20: {
  OPC_CheckPredicate, 68,                    //  3018:   check predicate 68
  OPC_CheckField, 6, 5, 0,                   //  3020:   check Inst[10:6] == 0x0
  OPC_Decode, 164, 9, 246, 1,                //  3024:   decode to CLZ using decoder 246
                                             //  3024:  }
  33, 11,                                    //  3029:  case 0x21: {
  OPC_CheckPredicate, 68,                    //  3031:   check predicate 68
  OPC_CheckField, 6, 5, 0,                   //  3033:   check Inst[10:6] == 0x0
  OPC_Decode, 144, 9, 246, 1,                //  3037:   decode to CLO using decoder 246
                                             //  3037:  }
  63, 0,                                     //  3042:  case 0x3f: {
  OPC_CheckPredicate, 68,                    //  3044:   check predicate 68
  OPC_Decode, 197, 19, 190, 1,               //  3046:   decode to SDBBP using decoder 190
                                             //  3046:  }
                                             //  3046:  } // switch Inst[5:0]
                                             //  3046: }
  29, 7,                                     //  3051: case 0x1d: {
  OPC_CheckPredicate, 68,                    //  3053:  check predicate 68
  OPC_Decode, 194, 14, 202, 1,               //  3055:  decode to JALX using decoder 202
                                             //  3055: }
  30, 197, 39,                               //  3060: case 0x1e: {
  OPC_SwitchField, 0, 6,                     //  3063:  switch Inst[5:0] {
  0, 39,                                     //  3066:  case 0x0: {
  OPC_SwitchField, 24, 2,                    //  3068:   switch Inst[25:24] {
  0, 7,                                      //  3071:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  3073:    check predicate 30
  OPC_Decode, 231, 6, 247, 1,                //  3075:    decode to ANDI_B using decoder 247
                                             //  3075:   }
  1, 7,                                      //  3080:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  3082:    check predicate 30
  OPC_Decode, 168, 18, 247, 1,               //  3084:    decode to ORI_B using decoder 247
                                             //  3084:   }
  2, 7,                                      //  3089:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  3091:    check predicate 30
  OPC_Decode, 156, 18, 247, 1,               //  3093:    decode to NORI_B using decoder 247
                                             //  3093:   }
  3, 0,                                      //  3098:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  3100:    check predicate 30
  OPC_Decode, 222, 22, 247, 1,               //  3102:    decode to XORI_B using decoder 247
                                             //  3102:   }
                                             //  3102:   } // switch Inst[25:24]
                                             //  3102:  }
  1, 30,                                     //  3107:  case 0x1: {
  OPC_SwitchField, 24, 2,                    //  3109:   switch Inst[25:24] {
  0, 7,                                      //  3112:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  3114:    check predicate 30
  OPC_Decode, 149, 8, 248, 1,                //  3116:    decode to BMNZI_B using decoder 248
                                             //  3116:   }
  1, 7,                                      //  3121:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  3123:    check predicate 30
  OPC_Decode, 151, 8, 248, 1,                //  3125:    decode to BMZI_B using decoder 248
                                             //  3125:   }
  2, 0,                                      //  3130:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  3132:    check predicate 30
  OPC_Decode, 193, 8, 248, 1,                //  3134:    decode to BSELI_B using decoder 248
                                             //  3134:   }
                                             //  3134:   } // switch Inst[25:24]
                                             //  3134:  }
  2, 30,                                     //  3139:  case 0x2: {
  OPC_SwitchField, 24, 2,                    //  3141:   switch Inst[25:24] {
  0, 7,                                      //  3144:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  3146:    check predicate 30
  OPC_Decode, 250, 19, 247, 1,               //  3148:    decode to SHF_B using decoder 247
                                             //  3148:   }
  1, 7,                                      //  3153:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  3155:    check predicate 30
  OPC_Decode, 251, 19, 249, 1,               //  3157:    decode to SHF_H using decoder 249
                                             //  3157:   }
  2, 0,                                      //  3162:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  3164:    check predicate 30
  OPC_Decode, 252, 19, 250, 1,               //  3166:    decode to SHF_W using decoder 250
                                             //  3166:   }
                                             //  3166:   } // switch Inst[25:24]
                                             //  3166:  }
  6, 219, 1,                                 //  3171:  case 0x6: {
  OPC_SwitchField, 21, 5,                    //  3174:   switch Inst[25:21] {
  0, 7,                                      //  3177:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  3179:    check predicate 30
  OPC_Decode, 199, 6, 251, 1,                //  3181:    decode to ADDVI_B using decoder 251
                                             //  3181:   }
  1, 7,                                      //  3186:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  3188:    check predicate 30
  OPC_Decode, 201, 6, 252, 1,                //  3190:    decode to ADDVI_H using decoder 252
                                             //  3190:   }
  2, 7,                                      //  3195:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  3197:    check predicate 30
  OPC_Decode, 202, 6, 253, 1,                //  3199:    decode to ADDVI_W using decoder 253
                                             //  3199:   }
  3, 7,                                      //  3204:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  3206:    check predicate 30
  OPC_Decode, 200, 6, 254, 1,                //  3208:    decode to ADDVI_D using decoder 254
                                             //  3208:   }
  4, 7,                                      //  3213:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  3215:    check predicate 30
  OPC_Decode, 191, 21, 251, 1,               //  3217:    decode to SUBVI_B using decoder 251
                                             //  3217:   }
  5, 7,                                      //  3222:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  3224:    check predicate 30
  OPC_Decode, 193, 21, 252, 1,               //  3226:    decode to SUBVI_H using decoder 252
                                             //  3226:   }
  6, 7,                                      //  3231:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  3233:    check predicate 30
  OPC_Decode, 194, 21, 253, 1,               //  3235:    decode to SUBVI_W using decoder 253
                                             //  3235:   }
  7, 7,                                      //  3240:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  3242:    check predicate 30
  OPC_Decode, 192, 21, 254, 1,               //  3244:    decode to SUBVI_D using decoder 254
                                             //  3244:   }
  8, 7,                                      //  3249:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  3251:    check predicate 30
  OPC_Decode, 131, 16, 251, 1,               //  3253:    decode to MAXI_S_B using decoder 251
                                             //  3253:   }
  9, 7,                                      //  3258:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  3260:    check predicate 30
  OPC_Decode, 133, 16, 252, 1,               //  3262:    decode to MAXI_S_H using decoder 252
                                             //  3262:   }
  10, 7,                                     //  3267:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  3269:    check predicate 30
  OPC_Decode, 134, 16, 253, 1,               //  3271:    decode to MAXI_S_W using decoder 253
                                             //  3271:   }
  11, 7,                                     //  3276:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  3278:    check predicate 30
  OPC_Decode, 132, 16, 254, 1,               //  3280:    decode to MAXI_S_D using decoder 254
                                             //  3280:   }
  12, 7,                                     //  3285:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  3287:    check predicate 30
  OPC_Decode, 135, 16, 251, 1,               //  3289:    decode to MAXI_U_B using decoder 251
                                             //  3289:   }
  13, 7,                                     //  3294:   case 0xd: {
  OPC_CheckPredicate, 30,                    //  3296:    check predicate 30
  OPC_Decode, 137, 16, 252, 1,               //  3298:    decode to MAXI_U_H using decoder 252
                                             //  3298:   }
  14, 7,                                     //  3303:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  3305:    check predicate 30
  OPC_Decode, 138, 16, 253, 1,               //  3307:    decode to MAXI_U_W using decoder 253
                                             //  3307:   }
  15, 7,                                     //  3312:   case 0xf: {
  OPC_CheckPredicate, 30,                    //  3314:    check predicate 30
  OPC_Decode, 136, 16, 254, 1,               //  3316:    decode to MAXI_U_D using decoder 254
                                             //  3316:   }
  16, 7,                                     //  3321:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  3323:    check predicate 30
  OPC_Decode, 190, 16, 251, 1,               //  3325:    decode to MINI_S_B using decoder 251
                                             //  3325:   }
  17, 7,                                     //  3330:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  3332:    check predicate 30
  OPC_Decode, 192, 16, 252, 1,               //  3334:    decode to MINI_S_H using decoder 252
                                             //  3334:   }
  18, 7,                                     //  3339:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  3341:    check predicate 30
  OPC_Decode, 193, 16, 253, 1,               //  3343:    decode to MINI_S_W using decoder 253
                                             //  3343:   }
  19, 7,                                     //  3348:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  3350:    check predicate 30
  OPC_Decode, 191, 16, 254, 1,               //  3352:    decode to MINI_S_D using decoder 254
                                             //  3352:   }
  20, 7,                                     //  3357:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  3359:    check predicate 30
  OPC_Decode, 194, 16, 251, 1,               //  3361:    decode to MINI_U_B using decoder 251
                                             //  3361:   }
  21, 7,                                     //  3366:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  3368:    check predicate 30
  OPC_Decode, 196, 16, 252, 1,               //  3370:    decode to MINI_U_H using decoder 252
                                             //  3370:   }
  22, 7,                                     //  3375:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  3377:    check predicate 30
  OPC_Decode, 197, 16, 253, 1,               //  3379:    decode to MINI_U_W using decoder 253
                                             //  3379:   }
  23, 0,                                     //  3384:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  3386:    check predicate 30
  OPC_Decode, 195, 16, 254, 1,               //  3388:    decode to MINI_U_D using decoder 254
                                             //  3388:   }
                                             //  3388:   } // switch Inst[25:21]
                                             //  3388:  }
  7, 219, 1,                                 //  3393:  case 0x7: {
  OPC_SwitchField, 21, 5,                    //  3396:   switch Inst[25:21] {
  0, 7,                                      //  3399:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  3401:    check predicate 30
  OPC_Decode, 236, 8, 251, 1,                //  3403:    decode to CEQI_B using decoder 251
                                             //  3403:   }
  1, 7,                                      //  3408:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  3410:    check predicate 30
  OPC_Decode, 238, 8, 252, 1,                //  3412:    decode to CEQI_H using decoder 252
                                             //  3412:   }
  2, 7,                                      //  3417:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  3419:    check predicate 30
  OPC_Decode, 239, 8, 253, 1,                //  3421:    decode to CEQI_W using decoder 253
                                             //  3421:   }
  3, 7,                                      //  3426:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  3428:    check predicate 30
  OPC_Decode, 237, 8, 254, 1,                //  3430:    decode to CEQI_D using decoder 254
                                             //  3430:   }
  8, 7,                                      //  3435:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  3437:    check predicate 30
  OPC_Decode, 148, 9, 251, 1,                //  3439:    decode to CLTI_S_B using decoder 251
                                             //  3439:   }
  9, 7,                                      //  3444:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  3446:    check predicate 30
  OPC_Decode, 150, 9, 252, 1,                //  3448:    decode to CLTI_S_H using decoder 252
                                             //  3448:   }
  10, 7,                                     //  3453:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  3455:    check predicate 30
  OPC_Decode, 151, 9, 253, 1,                //  3457:    decode to CLTI_S_W using decoder 253
                                             //  3457:   }
  11, 7,                                     //  3462:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  3464:    check predicate 30
  OPC_Decode, 149, 9, 254, 1,                //  3466:    decode to CLTI_S_D using decoder 254
                                             //  3466:   }
  12, 7,                                     //  3471:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  3473:    check predicate 30
  OPC_Decode, 152, 9, 251, 1,                //  3475:    decode to CLTI_U_B using decoder 251
                                             //  3475:   }
  13, 7,                                     //  3480:   case 0xd: {
  OPC_CheckPredicate, 30,                    //  3482:    check predicate 30
  OPC_Decode, 154, 9, 252, 1,                //  3484:    decode to CLTI_U_H using decoder 252
                                             //  3484:   }
  14, 7,                                     //  3489:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  3491:    check predicate 30
  OPC_Decode, 155, 9, 253, 1,                //  3493:    decode to CLTI_U_W using decoder 253
                                             //  3493:   }
  15, 7,                                     //  3498:   case 0xf: {
  OPC_CheckPredicate, 30,                    //  3500:    check predicate 30
  OPC_Decode, 153, 9, 254, 1,                //  3502:    decode to CLTI_U_D using decoder 254
                                             //  3502:   }
  16, 7,                                     //  3507:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  3509:    check predicate 30
  OPC_Decode, 128, 9, 251, 1,                //  3511:    decode to CLEI_S_B using decoder 251
                                             //  3511:   }
  17, 7,                                     //  3516:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  3518:    check predicate 30
  OPC_Decode, 130, 9, 252, 1,                //  3520:    decode to CLEI_S_H using decoder 252
                                             //  3520:   }
  18, 7,                                     //  3525:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  3527:    check predicate 30
  OPC_Decode, 131, 9, 253, 1,                //  3529:    decode to CLEI_S_W using decoder 253
                                             //  3529:   }
  19, 7,                                     //  3534:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  3536:    check predicate 30
  OPC_Decode, 129, 9, 254, 1,                //  3538:    decode to CLEI_S_D using decoder 254
                                             //  3538:   }
  20, 7,                                     //  3543:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  3545:    check predicate 30
  OPC_Decode, 132, 9, 251, 1,                //  3547:    decode to CLEI_U_B using decoder 251
                                             //  3547:   }
  21, 7,                                     //  3552:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  3554:    check predicate 30
  OPC_Decode, 134, 9, 252, 1,                //  3556:    decode to CLEI_U_H using decoder 252
                                             //  3556:   }
  22, 7,                                     //  3561:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  3563:    check predicate 30
  OPC_Decode, 135, 9, 253, 1,                //  3565:    decode to CLEI_U_W using decoder 253
                                             //  3565:   }
  23, 7,                                     //  3570:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  3572:    check predicate 30
  OPC_Decode, 133, 9, 254, 1,                //  3574:    decode to CLEI_U_D using decoder 254
                                             //  3574:   }
  24, 7,                                     //  3579:   case 0x18: {
  OPC_CheckPredicate, 30,                    //  3581:    check predicate 30
  OPC_Decode, 247, 14, 255, 1,               //  3583:    decode to LDI_B using decoder 255
                                             //  3583:   }
  25, 7,                                     //  3588:   case 0x19: {
  OPC_CheckPredicate, 30,                    //  3590:    check predicate 30
  OPC_Decode, 249, 14, 128, 2,               //  3592:    decode to LDI_H using decoder 256
                                             //  3592:   }
  26, 7,                                     //  3597:   case 0x1a: {
  OPC_CheckPredicate, 30,                    //  3599:    check predicate 30
  OPC_Decode, 250, 14, 129, 2,               //  3601:    decode to LDI_W using decoder 257
                                             //  3601:   }
  27, 0,                                     //  3606:   case 0x1b: {
  OPC_CheckPredicate, 30,                    //  3608:    check predicate 30
  OPC_Decode, 248, 14, 130, 2,               //  3610:    decode to LDI_D using decoder 258
                                             //  3610:   }
                                             //  3610:   } // switch Inst[25:21]
                                             //  3610:  }
  9, 147, 3,                                 //  3615:  case 0x9: {
  OPC_SwitchField, 22, 4,                    //  3618:   switch Inst[25:22] {
  0, 7,                                      //  3621:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  3623:    check predicate 30
  OPC_Decode, 191, 20, 131, 2,               //  3625:    decode to SLLI_D using decoder 259
                                             //  3625:   }
  1, 39,                                     //  3630:   case 0x1: {
  OPC_SwitchField, 21, 1,                    //  3632:    switch Inst[21] {
  0, 7,                                      //  3635:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  3637:     check predicate 30
  OPC_Decode, 193, 20, 253, 1,               //  3639:     decode to SLLI_W using decoder 253
                                             //  3639:    }
  1, 0,                                      //  3644:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  3646:     switch Inst[20] {
  0, 7,                                      //  3649:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  3651:      check predicate 30
  OPC_Decode, 192, 20, 132, 2,               //  3653:      decode to SLLI_H using decoder 260
                                             //  3653:     }
  1, 0,                                      //  3658:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  3660:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  3662:      check Inst[19] == 0x0
  OPC_Decode, 190, 20, 133, 2,               //  3666:      decode to SLLI_B using decoder 261
                                             //  3666:     }
                                             //  3666:     } // switch Inst[20]
                                             //  3666:    }
                                             //  3666:    } // switch Inst[21]
                                             //  3666:   }
  2, 7,                                      //  3671:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  3673:    check predicate 30
  OPC_Decode, 226, 20, 131, 2,               //  3675:    decode to SRAI_D using decoder 259
                                             //  3675:   }
  3, 39,                                     //  3680:   case 0x3: {
  OPC_SwitchField, 21, 1,                    //  3682:    switch Inst[21] {
  0, 7,                                      //  3685:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  3687:     check predicate 30
  OPC_Decode, 228, 20, 253, 1,               //  3689:     decode to SRAI_W using decoder 253
                                             //  3689:    }
  1, 0,                                      //  3694:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  3696:     switch Inst[20] {
  0, 7,                                      //  3699:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  3701:      check predicate 30
  OPC_Decode, 227, 20, 132, 2,               //  3703:      decode to SRAI_H using decoder 260
                                             //  3703:     }
  1, 0,                                      //  3708:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  3710:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  3712:      check Inst[19] == 0x0
  OPC_Decode, 225, 20, 133, 2,               //  3716:      decode to SRAI_B using decoder 261
                                             //  3716:     }
                                             //  3716:     } // switch Inst[20]
                                             //  3716:    }
                                             //  3716:    } // switch Inst[21]
                                             //  3716:   }
  4, 7,                                      //  3721:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  3723:    check predicate 30
  OPC_Decode, 248, 20, 131, 2,               //  3725:    decode to SRLI_D using decoder 259
                                             //  3725:   }
  5, 39,                                     //  3730:   case 0x5: {
  OPC_SwitchField, 21, 1,                    //  3732:    switch Inst[21] {
  0, 7,                                      //  3735:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  3737:     check predicate 30
  OPC_Decode, 250, 20, 253, 1,               //  3739:     decode to SRLI_W using decoder 253
                                             //  3739:    }
  1, 0,                                      //  3744:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  3746:     switch Inst[20] {
  0, 7,                                      //  3749:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  3751:      check predicate 30
  OPC_Decode, 249, 20, 132, 2,               //  3753:      decode to SRLI_H using decoder 260
                                             //  3753:     }
  1, 0,                                      //  3758:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  3760:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  3762:      check Inst[19] == 0x0
  OPC_Decode, 247, 20, 133, 2,               //  3766:      decode to SRLI_B using decoder 261
                                             //  3766:     }
                                             //  3766:     } // switch Inst[20]
                                             //  3766:    }
                                             //  3766:    } // switch Inst[21]
                                             //  3766:   }
  6, 7,                                      //  3771:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  3773:    check predicate 30
  OPC_Decode, 178, 7, 131, 2,                //  3775:    decode to BCLRI_D using decoder 259
                                             //  3775:   }
  7, 39,                                     //  3780:   case 0x7: {
  OPC_SwitchField, 21, 1,                    //  3782:    switch Inst[21] {
  0, 7,                                      //  3785:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  3787:     check predicate 30
  OPC_Decode, 180, 7, 253, 1,                //  3789:     decode to BCLRI_W using decoder 253
                                             //  3789:    }
  1, 0,                                      //  3794:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  3796:     switch Inst[20] {
  0, 7,                                      //  3799:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  3801:      check predicate 30
  OPC_Decode, 179, 7, 132, 2,                //  3803:      decode to BCLRI_H using decoder 260
                                             //  3803:     }
  1, 0,                                      //  3808:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  3810:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  3812:      check Inst[19] == 0x0
  OPC_Decode, 177, 7, 133, 2,                //  3816:      decode to BCLRI_B using decoder 261
                                             //  3816:     }
                                             //  3816:     } // switch Inst[20]
                                             //  3816:    }
                                             //  3816:    } // switch Inst[21]
                                             //  3816:   }
  8, 7,                                      //  3821:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  3823:    check predicate 30
  OPC_Decode, 196, 8, 131, 2,                //  3825:    decode to BSETI_D using decoder 259
                                             //  3825:   }
  9, 39,                                     //  3830:   case 0x9: {
  OPC_SwitchField, 21, 1,                    //  3832:    switch Inst[21] {
  0, 7,                                      //  3835:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  3837:     check predicate 30
  OPC_Decode, 198, 8, 253, 1,                //  3839:     decode to BSETI_W using decoder 253
                                             //  3839:    }
  1, 0,                                      //  3844:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  3846:     switch Inst[20] {
  0, 7,                                      //  3849:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  3851:      check predicate 30
  OPC_Decode, 197, 8, 132, 2,                //  3853:      decode to BSETI_H using decoder 260
                                             //  3853:     }
  1, 0,                                      //  3858:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  3860:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  3862:      check Inst[19] == 0x0
  OPC_Decode, 195, 8, 133, 2,                //  3866:      decode to BSETI_B using decoder 261
                                             //  3866:     }
                                             //  3866:     } // switch Inst[20]
                                             //  3866:    }
                                             //  3866:    } // switch Inst[21]
                                             //  3866:   }
  10, 7,                                     //  3871:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  3873:    check predicate 30
  OPC_Decode, 159, 8, 131, 2,                //  3875:    decode to BNEGI_D using decoder 259
                                             //  3875:   }
  11, 39,                                    //  3880:   case 0xb: {
  OPC_SwitchField, 21, 1,                    //  3882:    switch Inst[21] {
  0, 7,                                      //  3885:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  3887:     check predicate 30
  OPC_Decode, 161, 8, 253, 1,                //  3889:     decode to BNEGI_W using decoder 253
                                             //  3889:    }
  1, 0,                                      //  3894:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  3896:     switch Inst[20] {
  0, 7,                                      //  3899:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  3901:      check predicate 30
  OPC_Decode, 160, 8, 132, 2,                //  3903:      decode to BNEGI_H using decoder 260
                                             //  3903:     }
  1, 0,                                      //  3908:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  3910:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  3912:      check Inst[19] == 0x0
  OPC_Decode, 158, 8, 133, 2,                //  3916:      decode to BNEGI_B using decoder 261
                                             //  3916:     }
                                             //  3916:     } // switch Inst[20]
                                             //  3916:    }
                                             //  3916:    } // switch Inst[21]
                                             //  3916:   }
  12, 7,                                     //  3921:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  3923:    check predicate 30
  OPC_Decode, 230, 7, 134, 2,                //  3925:    decode to BINSLI_D using decoder 262
                                             //  3925:   }
  13, 39,                                    //  3930:   case 0xd: {
  OPC_SwitchField, 21, 1,                    //  3932:    switch Inst[21] {
  0, 7,                                      //  3935:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  3937:     check predicate 30
  OPC_Decode, 232, 7, 135, 2,                //  3939:     decode to BINSLI_W using decoder 263
                                             //  3939:    }
  1, 0,                                      //  3944:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  3946:     switch Inst[20] {
  0, 7,                                      //  3949:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  3951:      check predicate 30
  OPC_Decode, 231, 7, 136, 2,                //  3953:      decode to BINSLI_H using decoder 264
                                             //  3953:     }
  1, 0,                                      //  3958:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  3960:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  3962:      check Inst[19] == 0x0
  OPC_Decode, 229, 7, 137, 2,                //  3966:      decode to BINSLI_B using decoder 265
                                             //  3966:     }
                                             //  3966:     } // switch Inst[20]
                                             //  3966:    }
                                             //  3966:    } // switch Inst[21]
                                             //  3966:   }
  14, 7,                                     //  3971:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  3973:    check predicate 30
  OPC_Decode, 238, 7, 134, 2,                //  3975:    decode to BINSRI_D using decoder 262
                                             //  3975:   }
  15, 0,                                     //  3980:   case 0xf: {
  OPC_SwitchField, 21, 1,                    //  3982:    switch Inst[21] {
  0, 7,                                      //  3985:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  3987:     check predicate 30
  OPC_Decode, 240, 7, 135, 2,                //  3989:     decode to BINSRI_W using decoder 263
                                             //  3989:    }
  1, 0,                                      //  3994:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  3996:     switch Inst[20] {
  0, 7,                                      //  3999:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  4001:      check predicate 30
  OPC_Decode, 239, 7, 136, 2,                //  4003:      decode to BINSRI_H using decoder 264
                                             //  4003:     }
  1, 0,                                      //  4008:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  4010:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  4012:      check Inst[19] == 0x0
  OPC_Decode, 237, 7, 137, 2,                //  4016:      decode to BINSRI_B using decoder 265
                                             //  4016:     }
                                             //  4016:     } // switch Inst[20]
                                             //  4016:    }
                                             //  4016:    } // switch Inst[21]
                                             //  4016:   }
                                             //  4016:   } // switch Inst[25:22]
                                             //  4016:  }
  10, 203, 1,                                //  4021:  case 0xa: {
  OPC_SwitchField, 22, 4,                    //  4024:   switch Inst[25:22] {
  0, 7,                                      //  4027:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  4029:    check predicate 30
  OPC_Decode, 171, 19, 131, 2,               //  4031:    decode to SAT_S_D using decoder 259
                                             //  4031:   }
  1, 39,                                     //  4036:   case 0x1: {
  OPC_SwitchField, 21, 1,                    //  4038:    switch Inst[21] {
  0, 7,                                      //  4041:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  4043:     check predicate 30
  OPC_Decode, 173, 19, 253, 1,               //  4045:     decode to SAT_S_W using decoder 253
                                             //  4045:    }
  1, 0,                                      //  4050:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  4052:     switch Inst[20] {
  0, 7,                                      //  4055:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  4057:      check predicate 30
  OPC_Decode, 172, 19, 132, 2,               //  4059:      decode to SAT_S_H using decoder 260
                                             //  4059:     }
  1, 0,                                      //  4064:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  4066:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  4068:      check Inst[19] == 0x0
  OPC_Decode, 170, 19, 133, 2,               //  4072:      decode to SAT_S_B using decoder 261
                                             //  4072:     }
                                             //  4072:     } // switch Inst[20]
                                             //  4072:    }
                                             //  4072:    } // switch Inst[21]
                                             //  4072:   }
  2, 7,                                      //  4077:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  4079:    check predicate 30
  OPC_Decode, 175, 19, 131, 2,               //  4081:    decode to SAT_U_D using decoder 259
                                             //  4081:   }
  3, 39,                                     //  4086:   case 0x3: {
  OPC_SwitchField, 21, 1,                    //  4088:    switch Inst[21] {
  0, 7,                                      //  4091:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  4093:     check predicate 30
  OPC_Decode, 177, 19, 253, 1,               //  4095:     decode to SAT_U_W using decoder 253
                                             //  4095:    }
  1, 0,                                      //  4100:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  4102:     switch Inst[20] {
  0, 7,                                      //  4105:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  4107:      check predicate 30
  OPC_Decode, 176, 19, 132, 2,               //  4109:      decode to SAT_U_H using decoder 260
                                             //  4109:     }
  1, 0,                                      //  4114:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  4116:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  4118:      check Inst[19] == 0x0
  OPC_Decode, 174, 19, 133, 2,               //  4122:      decode to SAT_U_B using decoder 261
                                             //  4122:     }
                                             //  4122:     } // switch Inst[20]
                                             //  4122:    }
                                             //  4122:    } // switch Inst[21]
                                             //  4122:   }
  4, 7,                                      //  4127:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  4129:    check predicate 30
  OPC_Decode, 230, 20, 131, 2,               //  4131:    decode to SRARI_D using decoder 259
                                             //  4131:   }
  5, 39,                                     //  4136:   case 0x5: {
  OPC_SwitchField, 21, 1,                    //  4138:    switch Inst[21] {
  0, 7,                                      //  4141:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  4143:     check predicate 30
  OPC_Decode, 232, 20, 253, 1,               //  4145:     decode to SRARI_W using decoder 253
                                             //  4145:    }
  1, 0,                                      //  4150:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  4152:     switch Inst[20] {
  0, 7,                                      //  4155:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  4157:      check predicate 30
  OPC_Decode, 231, 20, 132, 2,               //  4159:      decode to SRARI_H using decoder 260
                                             //  4159:     }
  1, 0,                                      //  4164:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  4166:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  4168:      check Inst[19] == 0x0
  OPC_Decode, 229, 20, 133, 2,               //  4172:      decode to SRARI_B using decoder 261
                                             //  4172:     }
                                             //  4172:     } // switch Inst[20]
                                             //  4172:    }
                                             //  4172:    } // switch Inst[21]
                                             //  4172:   }
  6, 7,                                      //  4177:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  4179:    check predicate 30
  OPC_Decode, 252, 20, 131, 2,               //  4181:    decode to SRLRI_D using decoder 259
                                             //  4181:   }
  7, 0,                                      //  4186:   case 0x7: {
  OPC_SwitchField, 21, 1,                    //  4188:    switch Inst[21] {
  0, 7,                                      //  4191:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  4193:     check predicate 30
  OPC_Decode, 254, 20, 253, 1,               //  4195:     decode to SRLRI_W using decoder 253
                                             //  4195:    }
  1, 0,                                      //  4200:    case 0x1: {
  OPC_SwitchField, 20, 1,                    //  4202:     switch Inst[20] {
  0, 7,                                      //  4205:     case 0x0: {
  OPC_CheckPredicate, 30,                    //  4207:      check predicate 30
  OPC_Decode, 253, 20, 132, 2,               //  4209:      decode to SRLRI_H using decoder 260
                                             //  4209:     }
  1, 0,                                      //  4214:     case 0x1: {
  OPC_CheckPredicate, 30,                    //  4216:      check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  4218:      check Inst[19] == 0x0
  OPC_Decode, 251, 20, 133, 2,               //  4222:      decode to SRLRI_B using decoder 261
                                             //  4222:     }
                                             //  4222:     } // switch Inst[20]
                                             //  4222:    }
                                             //  4222:    } // switch Inst[21]
                                             //  4222:   }
                                             //  4222:   } // switch Inst[25:22]
                                             //  4222:  }
  13, 163, 2,                                //  4227:  case 0xd: {
  OPC_SwitchField, 21, 5,                    //  4230:   switch Inst[25:21] {
  0, 7,                                      //  4233:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  4235:    check predicate 30
  OPC_Decode, 196, 20, 138, 2,               //  4237:    decode to SLL_B using decoder 266
                                             //  4237:   }
  1, 7,                                      //  4242:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  4244:    check predicate 30
  OPC_Decode, 198, 20, 139, 2,               //  4246:    decode to SLL_H using decoder 267
                                             //  4246:   }
  2, 7,                                      //  4251:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  4253:    check predicate 30
  OPC_Decode, 201, 20, 140, 2,               //  4255:    decode to SLL_W using decoder 268
                                             //  4255:   }
  3, 7,                                      //  4260:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  4262:    check predicate 30
  OPC_Decode, 197, 20, 141, 2,               //  4264:    decode to SLL_D using decoder 269
                                             //  4264:   }
  4, 7,                                      //  4269:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  4271:    check predicate 30
  OPC_Decode, 239, 20, 138, 2,               //  4273:    decode to SRA_B using decoder 266
                                             //  4273:   }
  5, 7,                                      //  4278:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  4280:    check predicate 30
  OPC_Decode, 241, 20, 139, 2,               //  4282:    decode to SRA_H using decoder 267
                                             //  4282:   }
  6, 7,                                      //  4287:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  4289:    check predicate 30
  OPC_Decode, 243, 20, 140, 2,               //  4291:    decode to SRA_W using decoder 268
                                             //  4291:   }
  7, 7,                                      //  4296:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  4298:    check predicate 30
  OPC_Decode, 240, 20, 141, 2,               //  4300:    decode to SRA_D using decoder 269
                                             //  4300:   }
  8, 7,                                      //  4305:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  4307:    check predicate 30
  OPC_Decode, 133, 21, 138, 2,               //  4309:    decode to SRL_B using decoder 266
                                             //  4309:   }
  9, 7,                                      //  4314:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  4316:    check predicate 30
  OPC_Decode, 135, 21, 139, 2,               //  4318:    decode to SRL_H using decoder 267
                                             //  4318:   }
  10, 7,                                     //  4323:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  4325:    check predicate 30
  OPC_Decode, 137, 21, 140, 2,               //  4327:    decode to SRL_W using decoder 268
                                             //  4327:   }
  11, 7,                                     //  4332:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  4334:    check predicate 30
  OPC_Decode, 134, 21, 141, 2,               //  4336:    decode to SRL_D using decoder 269
                                             //  4336:   }
  12, 7,                                     //  4341:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  4343:    check predicate 30
  OPC_Decode, 181, 7, 138, 2,                //  4345:    decode to BCLR_B using decoder 266
                                             //  4345:   }
  13, 7,                                     //  4350:   case 0xd: {
  OPC_CheckPredicate, 30,                    //  4352:    check predicate 30
  OPC_Decode, 183, 7, 139, 2,                //  4354:    decode to BCLR_H using decoder 267
                                             //  4354:   }
  14, 7,                                     //  4359:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  4361:    check predicate 30
  OPC_Decode, 184, 7, 140, 2,                //  4363:    decode to BCLR_W using decoder 268
                                             //  4363:   }
  15, 7,                                     //  4368:   case 0xf: {
  OPC_CheckPredicate, 30,                    //  4370:    check predicate 30
  OPC_Decode, 182, 7, 141, 2,                //  4372:    decode to BCLR_D using decoder 269
                                             //  4372:   }
  16, 7,                                     //  4377:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  4379:    check predicate 30
  OPC_Decode, 199, 8, 138, 2,                //  4381:    decode to BSET_B using decoder 266
                                             //  4381:   }
  17, 7,                                     //  4386:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  4388:    check predicate 30
  OPC_Decode, 201, 8, 139, 2,                //  4390:    decode to BSET_H using decoder 267
                                             //  4390:   }
  18, 7,                                     //  4395:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  4397:    check predicate 30
  OPC_Decode, 202, 8, 140, 2,                //  4399:    decode to BSET_W using decoder 268
                                             //  4399:   }
  19, 7,                                     //  4404:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  4406:    check predicate 30
  OPC_Decode, 200, 8, 141, 2,                //  4408:    decode to BSET_D using decoder 269
                                             //  4408:   }
  20, 7,                                     //  4413:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  4415:    check predicate 30
  OPC_Decode, 162, 8, 138, 2,                //  4417:    decode to BNEG_B using decoder 266
                                             //  4417:   }
  21, 7,                                     //  4422:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  4424:    check predicate 30
  OPC_Decode, 164, 8, 139, 2,                //  4426:    decode to BNEG_H using decoder 267
                                             //  4426:   }
  22, 7,                                     //  4431:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  4433:    check predicate 30
  OPC_Decode, 165, 8, 140, 2,                //  4435:    decode to BNEG_W using decoder 268
                                             //  4435:   }
  23, 7,                                     //  4440:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  4442:    check predicate 30
  OPC_Decode, 163, 8, 141, 2,                //  4444:    decode to BNEG_D using decoder 269
                                             //  4444:   }
  24, 7,                                     //  4449:   case 0x18: {
  OPC_CheckPredicate, 30,                    //  4451:    check predicate 30
  OPC_Decode, 233, 7, 142, 2,                //  4453:    decode to BINSL_B using decoder 270
                                             //  4453:   }
  25, 7,                                     //  4458:   case 0x19: {
  OPC_CheckPredicate, 30,                    //  4460:    check predicate 30
  OPC_Decode, 235, 7, 143, 2,                //  4462:    decode to BINSL_H using decoder 271
                                             //  4462:   }
  26, 7,                                     //  4467:   case 0x1a: {
  OPC_CheckPredicate, 30,                    //  4469:    check predicate 30
  OPC_Decode, 236, 7, 144, 2,                //  4471:    decode to BINSL_W using decoder 272
                                             //  4471:   }
  27, 7,                                     //  4476:   case 0x1b: {
  OPC_CheckPredicate, 30,                    //  4478:    check predicate 30
  OPC_Decode, 234, 7, 145, 2,                //  4480:    decode to BINSL_D using decoder 273
                                             //  4480:   }
  28, 7,                                     //  4485:   case 0x1c: {
  OPC_CheckPredicate, 30,                    //  4487:    check predicate 30
  OPC_Decode, 241, 7, 142, 2,                //  4489:    decode to BINSR_B using decoder 270
                                             //  4489:   }
  29, 7,                                     //  4494:   case 0x1d: {
  OPC_CheckPredicate, 30,                    //  4496:    check predicate 30
  OPC_Decode, 243, 7, 143, 2,                //  4498:    decode to BINSR_H using decoder 271
                                             //  4498:   }
  30, 7,                                     //  4503:   case 0x1e: {
  OPC_CheckPredicate, 30,                    //  4505:    check predicate 30
  OPC_Decode, 244, 7, 144, 2,                //  4507:    decode to BINSR_W using decoder 272
                                             //  4507:   }
  31, 0,                                     //  4512:   case 0x1f: {
  OPC_CheckPredicate, 30,                    //  4514:    check predicate 30
  OPC_Decode, 242, 7, 145, 2,                //  4516:    decode to BINSR_D using decoder 273
                                             //  4516:   }
                                             //  4516:   } // switch Inst[25:21]
                                             //  4516:  }
  14, 163, 2,                                //  4521:  case 0xe: {
  OPC_SwitchField, 21, 5,                    //  4524:   switch Inst[25:21] {
  0, 7,                                      //  4527:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  4529:    check predicate 30
  OPC_Decode, 203, 6, 138, 2,                //  4531:    decode to ADDV_B using decoder 266
                                             //  4531:   }
  1, 7,                                      //  4536:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  4538:    check predicate 30
  OPC_Decode, 205, 6, 139, 2,                //  4540:    decode to ADDV_H using decoder 267
                                             //  4540:   }
  2, 7,                                      //  4545:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  4547:    check predicate 30
  OPC_Decode, 206, 6, 140, 2,                //  4549:    decode to ADDV_W using decoder 268
                                             //  4549:   }
  3, 7,                                      //  4554:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  4556:    check predicate 30
  OPC_Decode, 204, 6, 141, 2,                //  4558:    decode to ADDV_D using decoder 269
                                             //  4558:   }
  4, 7,                                      //  4563:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  4565:    check predicate 30
  OPC_Decode, 195, 21, 138, 2,               //  4567:    decode to SUBV_B using decoder 266
                                             //  4567:   }
  5, 7,                                      //  4572:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  4574:    check predicate 30
  OPC_Decode, 197, 21, 139, 2,               //  4576:    decode to SUBV_H using decoder 267
                                             //  4576:   }
  6, 7,                                      //  4581:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  4583:    check predicate 30
  OPC_Decode, 198, 21, 140, 2,               //  4585:    decode to SUBV_W using decoder 268
                                             //  4585:   }
  7, 7,                                      //  4590:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  4592:    check predicate 30
  OPC_Decode, 196, 21, 141, 2,               //  4594:    decode to SUBV_D using decoder 269
                                             //  4594:   }
  8, 7,                                      //  4599:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  4601:    check predicate 30
  OPC_Decode, 146, 16, 138, 2,               //  4603:    decode to MAX_S_B using decoder 266
                                             //  4603:   }
  9, 7,                                      //  4608:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  4610:    check predicate 30
  OPC_Decode, 148, 16, 139, 2,               //  4612:    decode to MAX_S_H using decoder 267
                                             //  4612:   }
  10, 7,                                     //  4617:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  4619:    check predicate 30
  OPC_Decode, 150, 16, 140, 2,               //  4621:    decode to MAX_S_W using decoder 268
                                             //  4621:   }
  11, 7,                                     //  4626:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  4628:    check predicate 30
  OPC_Decode, 147, 16, 141, 2,               //  4630:    decode to MAX_S_D using decoder 269
                                             //  4630:   }
  12, 7,                                     //  4635:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  4637:    check predicate 30
  OPC_Decode, 151, 16, 138, 2,               //  4639:    decode to MAX_U_B using decoder 266
                                             //  4639:   }
  13, 7,                                     //  4644:   case 0xd: {
  OPC_CheckPredicate, 30,                    //  4646:    check predicate 30
  OPC_Decode, 153, 16, 139, 2,               //  4648:    decode to MAX_U_H using decoder 267
                                             //  4648:   }
  14, 7,                                     //  4653:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  4655:    check predicate 30
  OPC_Decode, 154, 16, 140, 2,               //  4657:    decode to MAX_U_W using decoder 268
                                             //  4657:   }
  15, 7,                                     //  4662:   case 0xf: {
  OPC_CheckPredicate, 30,                    //  4664:    check predicate 30
  OPC_Decode, 152, 16, 141, 2,               //  4666:    decode to MAX_U_D using decoder 269
                                             //  4666:   }
  16, 7,                                     //  4671:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  4673:    check predicate 30
  OPC_Decode, 205, 16, 138, 2,               //  4675:    decode to MIN_S_B using decoder 266
                                             //  4675:   }
  17, 7,                                     //  4680:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  4682:    check predicate 30
  OPC_Decode, 207, 16, 139, 2,               //  4684:    decode to MIN_S_H using decoder 267
                                             //  4684:   }
  18, 7,                                     //  4689:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  4691:    check predicate 30
  OPC_Decode, 209, 16, 140, 2,               //  4693:    decode to MIN_S_W using decoder 268
                                             //  4693:   }
  19, 7,                                     //  4698:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  4700:    check predicate 30
  OPC_Decode, 206, 16, 141, 2,               //  4702:    decode to MIN_S_D using decoder 269
                                             //  4702:   }
  20, 7,                                     //  4707:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  4709:    check predicate 30
  OPC_Decode, 210, 16, 138, 2,               //  4711:    decode to MIN_U_B using decoder 266
                                             //  4711:   }
  21, 7,                                     //  4716:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  4718:    check predicate 30
  OPC_Decode, 212, 16, 139, 2,               //  4720:    decode to MIN_U_H using decoder 267
                                             //  4720:   }
  22, 7,                                     //  4725:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  4727:    check predicate 30
  OPC_Decode, 213, 16, 140, 2,               //  4729:    decode to MIN_U_W using decoder 268
                                             //  4729:   }
  23, 7,                                     //  4734:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  4736:    check predicate 30
  OPC_Decode, 211, 16, 141, 2,               //  4738:    decode to MIN_U_D using decoder 269
                                             //  4738:   }
  24, 7,                                     //  4743:   case 0x18: {
  OPC_CheckPredicate, 30,                    //  4745:    check predicate 30
  OPC_Decode, 139, 16, 138, 2,               //  4747:    decode to MAX_A_B using decoder 266
                                             //  4747:   }
  25, 7,                                     //  4752:   case 0x19: {
  OPC_CheckPredicate, 30,                    //  4754:    check predicate 30
  OPC_Decode, 141, 16, 139, 2,               //  4756:    decode to MAX_A_H using decoder 267
                                             //  4756:   }
  26, 7,                                     //  4761:   case 0x1a: {
  OPC_CheckPredicate, 30,                    //  4763:    check predicate 30
  OPC_Decode, 142, 16, 140, 2,               //  4765:    decode to MAX_A_W using decoder 268
                                             //  4765:   }
  27, 7,                                     //  4770:   case 0x1b: {
  OPC_CheckPredicate, 30,                    //  4772:    check predicate 30
  OPC_Decode, 140, 16, 141, 2,               //  4774:    decode to MAX_A_D using decoder 269
                                             //  4774:   }
  28, 7,                                     //  4779:   case 0x1c: {
  OPC_CheckPredicate, 30,                    //  4781:    check predicate 30
  OPC_Decode, 198, 16, 138, 2,               //  4783:    decode to MIN_A_B using decoder 266
                                             //  4783:   }
  29, 7,                                     //  4788:   case 0x1d: {
  OPC_CheckPredicate, 30,                    //  4790:    check predicate 30
  OPC_Decode, 200, 16, 139, 2,               //  4792:    decode to MIN_A_H using decoder 267
                                             //  4792:   }
  30, 7,                                     //  4797:   case 0x1e: {
  OPC_CheckPredicate, 30,                    //  4799:    check predicate 30
  OPC_Decode, 201, 16, 140, 2,               //  4801:    decode to MIN_A_W using decoder 268
                                             //  4801:   }
  31, 0,                                     //  4806:   case 0x1f: {
  OPC_CheckPredicate, 30,                    //  4808:    check predicate 30
  OPC_Decode, 199, 16, 141, 2,               //  4810:    decode to MIN_A_D using decoder 269
                                             //  4810:   }
                                             //  4810:   } // switch Inst[25:21]
                                             //  4810:  }
  15, 183, 1,                                //  4815:  case 0xf: {
  OPC_SwitchField, 21, 5,                    //  4818:   switch Inst[25:21] {
  0, 7,                                      //  4821:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  4823:    check predicate 30
  OPC_Decode, 240, 8, 138, 2,                //  4825:    decode to CEQ_B using decoder 266
                                             //  4825:   }
  1, 7,                                      //  4830:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  4832:    check predicate 30
  OPC_Decode, 242, 8, 139, 2,                //  4834:    decode to CEQ_H using decoder 267
                                             //  4834:   }
  2, 7,                                      //  4839:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  4841:    check predicate 30
  OPC_Decode, 243, 8, 140, 2,                //  4843:    decode to CEQ_W using decoder 268
                                             //  4843:   }
  3, 7,                                      //  4848:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  4850:    check predicate 30
  OPC_Decode, 241, 8, 141, 2,                //  4852:    decode to CEQ_D using decoder 269
                                             //  4852:   }
  8, 7,                                      //  4857:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  4859:    check predicate 30
  OPC_Decode, 156, 9, 138, 2,                //  4861:    decode to CLT_S_B using decoder 266
                                             //  4861:   }
  9, 7,                                      //  4866:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  4868:    check predicate 30
  OPC_Decode, 158, 9, 139, 2,                //  4870:    decode to CLT_S_H using decoder 267
                                             //  4870:   }
  10, 7,                                     //  4875:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  4877:    check predicate 30
  OPC_Decode, 159, 9, 140, 2,                //  4879:    decode to CLT_S_W using decoder 268
                                             //  4879:   }
  11, 7,                                     //  4884:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  4886:    check predicate 30
  OPC_Decode, 157, 9, 141, 2,                //  4888:    decode to CLT_S_D using decoder 269
                                             //  4888:   }
  12, 7,                                     //  4893:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  4895:    check predicate 30
  OPC_Decode, 160, 9, 138, 2,                //  4897:    decode to CLT_U_B using decoder 266
                                             //  4897:   }
  13, 7,                                     //  4902:   case 0xd: {
  OPC_CheckPredicate, 30,                    //  4904:    check predicate 30
  OPC_Decode, 162, 9, 139, 2,                //  4906:    decode to CLT_U_H using decoder 267
                                             //  4906:   }
  14, 7,                                     //  4911:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  4913:    check predicate 30
  OPC_Decode, 163, 9, 140, 2,                //  4915:    decode to CLT_U_W using decoder 268
                                             //  4915:   }
  15, 7,                                     //  4920:   case 0xf: {
  OPC_CheckPredicate, 30,                    //  4922:    check predicate 30
  OPC_Decode, 161, 9, 141, 2,                //  4924:    decode to CLT_U_D using decoder 269
                                             //  4924:   }
  16, 7,                                     //  4929:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  4931:    check predicate 30
  OPC_Decode, 136, 9, 138, 2,                //  4933:    decode to CLE_S_B using decoder 266
                                             //  4933:   }
  17, 7,                                     //  4938:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  4940:    check predicate 30
  OPC_Decode, 138, 9, 139, 2,                //  4942:    decode to CLE_S_H using decoder 267
                                             //  4942:   }
  18, 7,                                     //  4947:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  4949:    check predicate 30
  OPC_Decode, 139, 9, 140, 2,                //  4951:    decode to CLE_S_W using decoder 268
                                             //  4951:   }
  19, 7,                                     //  4956:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  4958:    check predicate 30
  OPC_Decode, 137, 9, 141, 2,                //  4960:    decode to CLE_S_D using decoder 269
                                             //  4960:   }
  20, 7,                                     //  4965:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  4967:    check predicate 30
  OPC_Decode, 140, 9, 138, 2,                //  4969:    decode to CLE_U_B using decoder 266
                                             //  4969:   }
  21, 7,                                     //  4974:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  4976:    check predicate 30
  OPC_Decode, 142, 9, 139, 2,                //  4978:    decode to CLE_U_H using decoder 267
                                             //  4978:   }
  22, 7,                                     //  4983:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  4985:    check predicate 30
  OPC_Decode, 143, 9, 140, 2,                //  4987:    decode to CLE_U_W using decoder 268
                                             //  4987:   }
  23, 0,                                     //  4992:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  4994:    check predicate 30
  OPC_Decode, 141, 9, 141, 2,                //  4996:    decode to CLE_U_D using decoder 269
                                             //  4996:   }
                                             //  4996:   } // switch Inst[25:21]
                                             //  4996:  }
  16, 163, 2,                                //  5001:  case 0x10: {
  OPC_SwitchField, 21, 5,                    //  5004:   switch Inst[25:21] {
  0, 7,                                      //  5007:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  5009:    check predicate 30
  OPC_Decode, 209, 6, 138, 2,                //  5011:    decode to ADD_A_B using decoder 266
                                             //  5011:   }
  1, 7,                                      //  5016:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  5018:    check predicate 30
  OPC_Decode, 211, 6, 139, 2,                //  5020:    decode to ADD_A_H using decoder 267
                                             //  5020:   }
  2, 7,                                      //  5025:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  5027:    check predicate 30
  OPC_Decode, 212, 6, 140, 2,                //  5029:    decode to ADD_A_W using decoder 268
                                             //  5029:   }
  3, 7,                                      //  5034:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  5036:    check predicate 30
  OPC_Decode, 210, 6, 141, 2,                //  5038:    decode to ADD_A_D using decoder 269
                                             //  5038:   }
  4, 7,                                      //  5043:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  5045:    check predicate 30
  OPC_Decode, 172, 6, 138, 2,                //  5047:    decode to ADDS_A_B using decoder 266
                                             //  5047:   }
  5, 7,                                      //  5052:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  5054:    check predicate 30
  OPC_Decode, 174, 6, 139, 2,                //  5056:    decode to ADDS_A_H using decoder 267
                                             //  5056:   }
  6, 7,                                      //  5061:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  5063:    check predicate 30
  OPC_Decode, 175, 6, 140, 2,                //  5065:    decode to ADDS_A_W using decoder 268
                                             //  5065:   }
  7, 7,                                      //  5070:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  5072:    check predicate 30
  OPC_Decode, 173, 6, 141, 2,                //  5074:    decode to ADDS_A_D using decoder 269
                                             //  5074:   }
  8, 7,                                      //  5079:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  5081:    check predicate 30
  OPC_Decode, 176, 6, 138, 2,                //  5083:    decode to ADDS_S_B using decoder 266
                                             //  5083:   }
  9, 7,                                      //  5088:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  5090:    check predicate 30
  OPC_Decode, 178, 6, 139, 2,                //  5092:    decode to ADDS_S_H using decoder 267
                                             //  5092:   }
  10, 7,                                     //  5097:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  5099:    check predicate 30
  OPC_Decode, 179, 6, 140, 2,                //  5101:    decode to ADDS_S_W using decoder 268
                                             //  5101:   }
  11, 7,                                     //  5106:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  5108:    check predicate 30
  OPC_Decode, 177, 6, 141, 2,                //  5110:    decode to ADDS_S_D using decoder 269
                                             //  5110:   }
  12, 7,                                     //  5115:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  5117:    check predicate 30
  OPC_Decode, 180, 6, 138, 2,                //  5119:    decode to ADDS_U_B using decoder 266
                                             //  5119:   }
  13, 7,                                     //  5124:   case 0xd: {
  OPC_CheckPredicate, 30,                    //  5126:    check predicate 30
  OPC_Decode, 182, 6, 139, 2,                //  5128:    decode to ADDS_U_H using decoder 267
                                             //  5128:   }
  14, 7,                                     //  5133:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  5135:    check predicate 30
  OPC_Decode, 183, 6, 140, 2,                //  5137:    decode to ADDS_U_W using decoder 268
                                             //  5137:   }
  15, 7,                                     //  5142:   case 0xf: {
  OPC_CheckPredicate, 30,                    //  5144:    check predicate 30
  OPC_Decode, 181, 6, 141, 2,                //  5146:    decode to ADDS_U_D using decoder 269
                                             //  5146:   }
  16, 7,                                     //  5151:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  5153:    check predicate 30
  OPC_Decode, 133, 7, 138, 2,                //  5155:    decode to AVE_S_B using decoder 266
                                             //  5155:   }
  17, 7,                                     //  5160:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  5162:    check predicate 30
  OPC_Decode, 135, 7, 139, 2,                //  5164:    decode to AVE_S_H using decoder 267
                                             //  5164:   }
  18, 7,                                     //  5169:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  5171:    check predicate 30
  OPC_Decode, 136, 7, 140, 2,                //  5173:    decode to AVE_S_W using decoder 268
                                             //  5173:   }
  19, 7,                                     //  5178:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  5180:    check predicate 30
  OPC_Decode, 134, 7, 141, 2,                //  5182:    decode to AVE_S_D using decoder 269
                                             //  5182:   }
  20, 7,                                     //  5187:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  5189:    check predicate 30
  OPC_Decode, 137, 7, 138, 2,                //  5191:    decode to AVE_U_B using decoder 266
                                             //  5191:   }
  21, 7,                                     //  5196:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  5198:    check predicate 30
  OPC_Decode, 139, 7, 139, 2,                //  5200:    decode to AVE_U_H using decoder 267
                                             //  5200:   }
  22, 7,                                     //  5205:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  5207:    check predicate 30
  OPC_Decode, 140, 7, 140, 2,                //  5209:    decode to AVE_U_W using decoder 268
                                             //  5209:   }
  23, 7,                                     //  5214:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  5216:    check predicate 30
  OPC_Decode, 138, 7, 141, 2,                //  5218:    decode to AVE_U_D using decoder 269
                                             //  5218:   }
  24, 7,                                     //  5223:   case 0x18: {
  OPC_CheckPredicate, 30,                    //  5225:    check predicate 30
  OPC_Decode, 253, 6, 138, 2,                //  5227:    decode to AVER_S_B using decoder 266
                                             //  5227:   }
  25, 7,                                     //  5232:   case 0x19: {
  OPC_CheckPredicate, 30,                    //  5234:    check predicate 30
  OPC_Decode, 255, 6, 139, 2,                //  5236:    decode to AVER_S_H using decoder 267
                                             //  5236:   }
  26, 7,                                     //  5241:   case 0x1a: {
  OPC_CheckPredicate, 30,                    //  5243:    check predicate 30
  OPC_Decode, 128, 7, 140, 2,                //  5245:    decode to AVER_S_W using decoder 268
                                             //  5245:   }
  27, 7,                                     //  5250:   case 0x1b: {
  OPC_CheckPredicate, 30,                    //  5252:    check predicate 30
  OPC_Decode, 254, 6, 141, 2,                //  5254:    decode to AVER_S_D using decoder 269
                                             //  5254:   }
  28, 7,                                     //  5259:   case 0x1c: {
  OPC_CheckPredicate, 30,                    //  5261:    check predicate 30
  OPC_Decode, 129, 7, 138, 2,                //  5263:    decode to AVER_U_B using decoder 266
                                             //  5263:   }
  29, 7,                                     //  5268:   case 0x1d: {
  OPC_CheckPredicate, 30,                    //  5270:    check predicate 30
  OPC_Decode, 131, 7, 139, 2,                //  5272:    decode to AVER_U_H using decoder 267
                                             //  5272:   }
  30, 7,                                     //  5277:   case 0x1e: {
  OPC_CheckPredicate, 30,                    //  5279:    check predicate 30
  OPC_Decode, 132, 7, 140, 2,                //  5281:    decode to AVER_U_W using decoder 268
                                             //  5281:   }
  31, 0,                                     //  5286:   case 0x1f: {
  OPC_CheckPredicate, 30,                    //  5288:    check predicate 30
  OPC_Decode, 130, 7, 141, 2,                //  5290:    decode to AVER_U_D using decoder 269
                                             //  5290:   }
                                             //  5290:   } // switch Inst[25:21]
                                             //  5290:  }
  17, 219, 1,                                //  5295:  case 0x11: {
  OPC_SwitchField, 21, 5,                    //  5298:   switch Inst[25:21] {
  0, 7,                                      //  5301:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  5303:    check predicate 30
  OPC_Decode, 168, 21, 138, 2,               //  5305:    decode to SUBS_S_B using decoder 266
                                             //  5305:   }
  1, 7,                                      //  5310:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  5312:    check predicate 30
  OPC_Decode, 170, 21, 139, 2,               //  5314:    decode to SUBS_S_H using decoder 267
                                             //  5314:   }
  2, 7,                                      //  5319:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  5321:    check predicate 30
  OPC_Decode, 171, 21, 140, 2,               //  5323:    decode to SUBS_S_W using decoder 268
                                             //  5323:   }
  3, 7,                                      //  5328:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  5330:    check predicate 30
  OPC_Decode, 169, 21, 141, 2,               //  5332:    decode to SUBS_S_D using decoder 269
                                             //  5332:   }
  4, 7,                                      //  5337:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  5339:    check predicate 30
  OPC_Decode, 172, 21, 138, 2,               //  5341:    decode to SUBS_U_B using decoder 266
                                             //  5341:   }
  5, 7,                                      //  5346:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  5348:    check predicate 30
  OPC_Decode, 174, 21, 139, 2,               //  5350:    decode to SUBS_U_H using decoder 267
                                             //  5350:   }
  6, 7,                                      //  5355:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  5357:    check predicate 30
  OPC_Decode, 175, 21, 140, 2,               //  5359:    decode to SUBS_U_W using decoder 268
                                             //  5359:   }
  7, 7,                                      //  5364:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  5366:    check predicate 30
  OPC_Decode, 173, 21, 141, 2,               //  5368:    decode to SUBS_U_D using decoder 269
                                             //  5368:   }
  8, 7,                                      //  5373:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  5375:    check predicate 30
  OPC_Decode, 160, 21, 138, 2,               //  5377:    decode to SUBSUS_U_B using decoder 266
                                             //  5377:   }
  9, 7,                                      //  5382:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  5384:    check predicate 30
  OPC_Decode, 162, 21, 139, 2,               //  5386:    decode to SUBSUS_U_H using decoder 267
                                             //  5386:   }
  10, 7,                                     //  5391:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  5393:    check predicate 30
  OPC_Decode, 163, 21, 140, 2,               //  5395:    decode to SUBSUS_U_W using decoder 268
                                             //  5395:   }
  11, 7,                                     //  5400:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  5402:    check predicate 30
  OPC_Decode, 161, 21, 141, 2,               //  5404:    decode to SUBSUS_U_D using decoder 269
                                             //  5404:   }
  12, 7,                                     //  5409:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  5411:    check predicate 30
  OPC_Decode, 164, 21, 138, 2,               //  5413:    decode to SUBSUU_S_B using decoder 266
                                             //  5413:   }
  13, 7,                                     //  5418:   case 0xd: {
  OPC_CheckPredicate, 30,                    //  5420:    check predicate 30
  OPC_Decode, 166, 21, 139, 2,               //  5422:    decode to SUBSUU_S_H using decoder 267
                                             //  5422:   }
  14, 7,                                     //  5427:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  5429:    check predicate 30
  OPC_Decode, 167, 21, 140, 2,               //  5431:    decode to SUBSUU_S_W using decoder 268
                                             //  5431:   }
  15, 7,                                     //  5436:   case 0xf: {
  OPC_CheckPredicate, 30,                    //  5438:    check predicate 30
  OPC_Decode, 165, 21, 141, 2,               //  5440:    decode to SUBSUU_S_D using decoder 269
                                             //  5440:   }
  16, 7,                                     //  5445:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  5447:    check predicate 30
  OPC_Decode, 241, 6, 138, 2,                //  5449:    decode to ASUB_S_B using decoder 266
                                             //  5449:   }
  17, 7,                                     //  5454:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  5456:    check predicate 30
  OPC_Decode, 243, 6, 139, 2,                //  5458:    decode to ASUB_S_H using decoder 267
                                             //  5458:   }
  18, 7,                                     //  5463:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  5465:    check predicate 30
  OPC_Decode, 244, 6, 140, 2,                //  5467:    decode to ASUB_S_W using decoder 268
                                             //  5467:   }
  19, 7,                                     //  5472:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  5474:    check predicate 30
  OPC_Decode, 242, 6, 141, 2,                //  5476:    decode to ASUB_S_D using decoder 269
                                             //  5476:   }
  20, 7,                                     //  5481:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  5483:    check predicate 30
  OPC_Decode, 245, 6, 138, 2,                //  5485:    decode to ASUB_U_B using decoder 266
                                             //  5485:   }
  21, 7,                                     //  5490:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  5492:    check predicate 30
  OPC_Decode, 247, 6, 139, 2,                //  5494:    decode to ASUB_U_H using decoder 267
                                             //  5494:   }
  22, 7,                                     //  5499:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  5501:    check predicate 30
  OPC_Decode, 248, 6, 140, 2,                //  5503:    decode to ASUB_U_W using decoder 268
                                             //  5503:   }
  23, 0,                                     //  5508:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  5510:    check predicate 30
  OPC_Decode, 246, 6, 141, 2,                //  5512:    decode to ASUB_U_D using decoder 269
                                             //  5512:   }
                                             //  5512:   } // switch Inst[25:21]
                                             //  5512:  }
  18, 255, 1,                                //  5517:  case 0x12: {
  OPC_SwitchField, 21, 5,                    //  5520:   switch Inst[25:21] {
  0, 7,                                      //  5523:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  5525:    check predicate 30
  OPC_Decode, 246, 17, 138, 2,               //  5527:    decode to MULV_B using decoder 266
                                             //  5527:   }
  1, 7,                                      //  5532:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  5534:    check predicate 30
  OPC_Decode, 248, 17, 139, 2,               //  5536:    decode to MULV_H using decoder 267
                                             //  5536:   }
  2, 7,                                      //  5541:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  5543:    check predicate 30
  OPC_Decode, 249, 17, 140, 2,               //  5545:    decode to MULV_W using decoder 268
                                             //  5545:   }
  3, 7,                                      //  5550:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  5552:    check predicate 30
  OPC_Decode, 247, 17, 141, 2,               //  5554:    decode to MULV_D using decoder 269
                                             //  5554:   }
  4, 7,                                      //  5559:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  5561:    check predicate 30
  OPC_Decode, 233, 15, 142, 2,               //  5563:    decode to MADDV_B using decoder 270
                                             //  5563:   }
  5, 7,                                      //  5568:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  5570:    check predicate 30
  OPC_Decode, 235, 15, 143, 2,               //  5572:    decode to MADDV_H using decoder 271
                                             //  5572:   }
  6, 7,                                      //  5577:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  5579:    check predicate 30
  OPC_Decode, 236, 15, 144, 2,               //  5581:    decode to MADDV_W using decoder 272
                                             //  5581:   }
  7, 7,                                      //  5586:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  5588:    check predicate 30
  OPC_Decode, 234, 15, 145, 2,               //  5590:    decode to MADDV_D using decoder 273
                                             //  5590:   }
  8, 7,                                      //  5595:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  5597:    check predicate 30
  OPC_Decode, 156, 17, 142, 2,               //  5599:    decode to MSUBV_B using decoder 270
                                             //  5599:   }
  9, 7,                                      //  5604:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  5606:    check predicate 30
  OPC_Decode, 158, 17, 143, 2,               //  5608:    decode to MSUBV_H using decoder 271
                                             //  5608:   }
  10, 7,                                     //  5613:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  5615:    check predicate 30
  OPC_Decode, 159, 17, 144, 2,               //  5617:    decode to MSUBV_W using decoder 272
                                             //  5617:   }
  11, 7,                                     //  5622:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  5624:    check predicate 30
  OPC_Decode, 157, 17, 145, 2,               //  5626:    decode to MSUBV_D using decoder 273
                                             //  5626:   }
  16, 7,                                     //  5631:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  5633:    check predicate 30
  OPC_Decode, 185, 11, 138, 2,               //  5635:    decode to DIV_S_B using decoder 266
                                             //  5635:   }
  17, 7,                                     //  5640:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  5642:    check predicate 30
  OPC_Decode, 187, 11, 139, 2,               //  5644:    decode to DIV_S_H using decoder 267
                                             //  5644:   }
  18, 7,                                     //  5649:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  5651:    check predicate 30
  OPC_Decode, 188, 11, 140, 2,               //  5653:    decode to DIV_S_W using decoder 268
                                             //  5653:   }
  19, 7,                                     //  5658:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  5660:    check predicate 30
  OPC_Decode, 186, 11, 141, 2,               //  5662:    decode to DIV_S_D using decoder 269
                                             //  5662:   }
  20, 7,                                     //  5667:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  5669:    check predicate 30
  OPC_Decode, 189, 11, 138, 2,               //  5671:    decode to DIV_U_B using decoder 266
                                             //  5671:   }
  21, 7,                                     //  5676:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  5678:    check predicate 30
  OPC_Decode, 191, 11, 139, 2,               //  5680:    decode to DIV_U_H using decoder 267
                                             //  5680:   }
  22, 7,                                     //  5685:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  5687:    check predicate 30
  OPC_Decode, 192, 11, 140, 2,               //  5689:    decode to DIV_U_W using decoder 268
                                             //  5689:   }
  23, 7,                                     //  5694:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  5696:    check predicate 30
  OPC_Decode, 190, 11, 141, 2,               //  5698:    decode to DIV_U_D using decoder 269
                                             //  5698:   }
  24, 7,                                     //  5703:   case 0x18: {
  OPC_CheckPredicate, 30,                    //  5705:    check predicate 30
  OPC_Decode, 220, 16, 138, 2,               //  5707:    decode to MOD_S_B using decoder 266
                                             //  5707:   }
  25, 7,                                     //  5712:   case 0x19: {
  OPC_CheckPredicate, 30,                    //  5714:    check predicate 30
  OPC_Decode, 222, 16, 139, 2,               //  5716:    decode to MOD_S_H using decoder 267
                                             //  5716:   }
  26, 7,                                     //  5721:   case 0x1a: {
  OPC_CheckPredicate, 30,                    //  5723:    check predicate 30
  OPC_Decode, 223, 16, 140, 2,               //  5725:    decode to MOD_S_W using decoder 268
                                             //  5725:   }
  27, 7,                                     //  5730:   case 0x1b: {
  OPC_CheckPredicate, 30,                    //  5732:    check predicate 30
  OPC_Decode, 221, 16, 141, 2,               //  5734:    decode to MOD_S_D using decoder 269
                                             //  5734:   }
  28, 7,                                     //  5739:   case 0x1c: {
  OPC_CheckPredicate, 30,                    //  5741:    check predicate 30
  OPC_Decode, 224, 16, 138, 2,               //  5743:    decode to MOD_U_B using decoder 266
                                             //  5743:   }
  29, 7,                                     //  5748:   case 0x1d: {
  OPC_CheckPredicate, 30,                    //  5750:    check predicate 30
  OPC_Decode, 226, 16, 139, 2,               //  5752:    decode to MOD_U_H using decoder 267
                                             //  5752:   }
  30, 7,                                     //  5757:   case 0x1e: {
  OPC_CheckPredicate, 30,                    //  5759:    check predicate 30
  OPC_Decode, 227, 16, 140, 2,               //  5761:    decode to MOD_U_W using decoder 268
                                             //  5761:   }
  31, 0,                                     //  5766:   case 0x1f: {
  OPC_CheckPredicate, 30,                    //  5768:    check predicate 30
  OPC_Decode, 225, 16, 141, 2,               //  5770:    decode to MOD_U_D using decoder 269
                                             //  5770:   }
                                             //  5770:   } // switch Inst[25:21]
                                             //  5770:  }
  19, 165, 1,                                //  5775:  case 0x13: {
  OPC_SwitchField, 21, 5,                    //  5778:   switch Inst[25:21] {
  1, 7,                                      //  5781:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  5783:    check predicate 30
  OPC_Decode, 218, 11, 146, 2,               //  5785:    decode to DOTP_S_H using decoder 274
                                             //  5785:   }
  2, 7,                                      //  5790:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  5792:    check predicate 30
  OPC_Decode, 219, 11, 147, 2,               //  5794:    decode to DOTP_S_W using decoder 275
                                             //  5794:   }
  3, 7,                                      //  5799:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  5801:    check predicate 30
  OPC_Decode, 217, 11, 148, 2,               //  5803:    decode to DOTP_S_D using decoder 276
                                             //  5803:   }
  5, 7,                                      //  5808:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  5810:    check predicate 30
  OPC_Decode, 221, 11, 146, 2,               //  5812:    decode to DOTP_U_H using decoder 274
                                             //  5812:   }
  6, 7,                                      //  5817:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  5819:    check predicate 30
  OPC_Decode, 222, 11, 147, 2,               //  5821:    decode to DOTP_U_W using decoder 275
                                             //  5821:   }
  7, 7,                                      //  5826:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  5828:    check predicate 30
  OPC_Decode, 220, 11, 148, 2,               //  5830:    decode to DOTP_U_D using decoder 276
                                             //  5830:   }
  9, 7,                                      //  5835:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  5837:    check predicate 30
  OPC_Decode, 224, 11, 149, 2,               //  5839:    decode to DPADD_S_H using decoder 277
                                             //  5839:   }
  10, 7,                                     //  5844:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  5846:    check predicate 30
  OPC_Decode, 225, 11, 150, 2,               //  5848:    decode to DPADD_S_W using decoder 278
                                             //  5848:   }
  11, 7,                                     //  5853:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  5855:    check predicate 30
  OPC_Decode, 223, 11, 151, 2,               //  5857:    decode to DPADD_S_D using decoder 279
                                             //  5857:   }
  13, 7,                                     //  5862:   case 0xd: {
  OPC_CheckPredicate, 30,                    //  5864:    check predicate 30
  OPC_Decode, 227, 11, 149, 2,               //  5866:    decode to DPADD_U_H using decoder 277
                                             //  5866:   }
  14, 7,                                     //  5871:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  5873:    check predicate 30
  OPC_Decode, 228, 11, 150, 2,               //  5875:    decode to DPADD_U_W using decoder 278
                                             //  5875:   }
  15, 7,                                     //  5880:   case 0xf: {
  OPC_CheckPredicate, 30,                    //  5882:    check predicate 30
  OPC_Decode, 226, 11, 151, 2,               //  5884:    decode to DPADD_U_D using decoder 279
                                             //  5884:   }
  17, 7,                                     //  5889:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  5891:    check predicate 30
  OPC_Decode, 255, 11, 149, 2,               //  5893:    decode to DPSUB_S_H using decoder 277
                                             //  5893:   }
  18, 7,                                     //  5898:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  5900:    check predicate 30
  OPC_Decode, 128, 12, 150, 2,               //  5902:    decode to DPSUB_S_W using decoder 278
                                             //  5902:   }
  19, 7,                                     //  5907:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  5909:    check predicate 30
  OPC_Decode, 254, 11, 151, 2,               //  5911:    decode to DPSUB_S_D using decoder 279
                                             //  5911:   }
  21, 7,                                     //  5916:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  5918:    check predicate 30
  OPC_Decode, 130, 12, 149, 2,               //  5920:    decode to DPSUB_U_H using decoder 277
                                             //  5920:   }
  22, 7,                                     //  5925:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  5927:    check predicate 30
  OPC_Decode, 131, 12, 150, 2,               //  5929:    decode to DPSUB_U_W using decoder 278
                                             //  5929:   }
  23, 0,                                     //  5934:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  5936:    check predicate 30
  OPC_Decode, 129, 12, 151, 2,               //  5938:    decode to DPSUB_U_D using decoder 279
                                             //  5938:   }
                                             //  5938:   } // switch Inst[25:21]
                                             //  5938:  }
  20, 163, 2,                                //  5943:  case 0x14: {
  OPC_SwitchField, 21, 5,                    //  5946:   switch Inst[25:21] {
  0, 7,                                      //  5949:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  5951:    check predicate 30
  OPC_Decode, 181, 20, 152, 2,               //  5953:    decode to SLD_B using decoder 280
                                             //  5953:   }
  1, 7,                                      //  5958:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  5960:    check predicate 30
  OPC_Decode, 183, 20, 153, 2,               //  5962:    decode to SLD_H using decoder 281
                                             //  5962:   }
  2, 7,                                      //  5967:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  5969:    check predicate 30
  OPC_Decode, 184, 20, 154, 2,               //  5971:    decode to SLD_W using decoder 282
                                             //  5971:   }
  3, 7,                                      //  5976:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  5978:    check predicate 30
  OPC_Decode, 182, 20, 155, 2,               //  5980:    decode to SLD_D using decoder 283
                                             //  5980:   }
  4, 7,                                      //  5985:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  5987:    check predicate 30
  OPC_Decode, 220, 20, 156, 2,               //  5989:    decode to SPLAT_B using decoder 284
                                             //  5989:   }
  5, 7,                                      //  5994:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  5996:    check predicate 30
  OPC_Decode, 222, 20, 157, 2,               //  5998:    decode to SPLAT_H using decoder 285
                                             //  5998:   }
  6, 7,                                      //  6003:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  6005:    check predicate 30
  OPC_Decode, 223, 20, 158, 2,               //  6007:    decode to SPLAT_W using decoder 286
                                             //  6007:   }
  7, 7,                                      //  6012:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  6014:    check predicate 30
  OPC_Decode, 221, 20, 159, 2,               //  6016:    decode to SPLAT_D using decoder 287
                                             //  6016:   }
  8, 7,                                      //  6021:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  6023:    check predicate 30
  OPC_Decode, 182, 18, 138, 2,               //  6025:    decode to PCKEV_B using decoder 266
                                             //  6025:   }
  9, 7,                                      //  6030:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  6032:    check predicate 30
  OPC_Decode, 184, 18, 139, 2,               //  6034:    decode to PCKEV_H using decoder 267
                                             //  6034:   }
  10, 7,                                     //  6039:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  6041:    check predicate 30
  OPC_Decode, 185, 18, 140, 2,               //  6043:    decode to PCKEV_W using decoder 268
                                             //  6043:   }
  11, 7,                                     //  6048:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  6050:    check predicate 30
  OPC_Decode, 183, 18, 141, 2,               //  6052:    decode to PCKEV_D using decoder 269
                                             //  6052:   }
  12, 7,                                     //  6057:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  6059:    check predicate 30
  OPC_Decode, 186, 18, 138, 2,               //  6061:    decode to PCKOD_B using decoder 266
                                             //  6061:   }
  13, 7,                                     //  6066:   case 0xd: {
  OPC_CheckPredicate, 30,                    //  6068:    check predicate 30
  OPC_Decode, 188, 18, 139, 2,               //  6070:    decode to PCKOD_H using decoder 267
                                             //  6070:   }
  14, 7,                                     //  6075:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  6077:    check predicate 30
  OPC_Decode, 189, 18, 140, 2,               //  6079:    decode to PCKOD_W using decoder 268
                                             //  6079:   }
  15, 7,                                     //  6084:   case 0xf: {
  OPC_CheckPredicate, 30,                    //  6086:    check predicate 30
  OPC_Decode, 187, 18, 141, 2,               //  6088:    decode to PCKOD_D using decoder 269
                                             //  6088:   }
  16, 7,                                     //  6093:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  6095:    check predicate 30
  OPC_Decode, 155, 14, 138, 2,               //  6097:    decode to ILVL_B using decoder 266
                                             //  6097:   }
  17, 7,                                     //  6102:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  6104:    check predicate 30
  OPC_Decode, 157, 14, 139, 2,               //  6106:    decode to ILVL_H using decoder 267
                                             //  6106:   }
  18, 7,                                     //  6111:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  6113:    check predicate 30
  OPC_Decode, 158, 14, 140, 2,               //  6115:    decode to ILVL_W using decoder 268
                                             //  6115:   }
  19, 7,                                     //  6120:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  6122:    check predicate 30
  OPC_Decode, 156, 14, 141, 2,               //  6124:    decode to ILVL_D using decoder 269
                                             //  6124:   }
  20, 7,                                     //  6129:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  6131:    check predicate 30
  OPC_Decode, 163, 14, 138, 2,               //  6133:    decode to ILVR_B using decoder 266
                                             //  6133:   }
  21, 7,                                     //  6138:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  6140:    check predicate 30
  OPC_Decode, 165, 14, 139, 2,               //  6142:    decode to ILVR_H using decoder 267
                                             //  6142:   }
  22, 7,                                     //  6147:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  6149:    check predicate 30
  OPC_Decode, 166, 14, 140, 2,               //  6151:    decode to ILVR_W using decoder 268
                                             //  6151:   }
  23, 7,                                     //  6156:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  6158:    check predicate 30
  OPC_Decode, 164, 14, 141, 2,               //  6160:    decode to ILVR_D using decoder 269
                                             //  6160:   }
  24, 7,                                     //  6165:   case 0x18: {
  OPC_CheckPredicate, 30,                    //  6167:    check predicate 30
  OPC_Decode, 151, 14, 138, 2,               //  6169:    decode to ILVEV_B using decoder 266
                                             //  6169:   }
  25, 7,                                     //  6174:   case 0x19: {
  OPC_CheckPredicate, 30,                    //  6176:    check predicate 30
  OPC_Decode, 153, 14, 139, 2,               //  6178:    decode to ILVEV_H using decoder 267
                                             //  6178:   }
  26, 7,                                     //  6183:   case 0x1a: {
  OPC_CheckPredicate, 30,                    //  6185:    check predicate 30
  OPC_Decode, 154, 14, 140, 2,               //  6187:    decode to ILVEV_W using decoder 268
                                             //  6187:   }
  27, 7,                                     //  6192:   case 0x1b: {
  OPC_CheckPredicate, 30,                    //  6194:    check predicate 30
  OPC_Decode, 152, 14, 141, 2,               //  6196:    decode to ILVEV_D using decoder 269
                                             //  6196:   }
  28, 7,                                     //  6201:   case 0x1c: {
  OPC_CheckPredicate, 30,                    //  6203:    check predicate 30
  OPC_Decode, 159, 14, 138, 2,               //  6205:    decode to ILVOD_B using decoder 266
                                             //  6205:   }
  29, 7,                                     //  6210:   case 0x1d: {
  OPC_CheckPredicate, 30,                    //  6212:    check predicate 30
  OPC_Decode, 161, 14, 139, 2,               //  6214:    decode to ILVOD_H using decoder 267
                                             //  6214:   }
  30, 7,                                     //  6219:   case 0x1e: {
  OPC_CheckPredicate, 30,                    //  6221:    check predicate 30
  OPC_Decode, 162, 14, 140, 2,               //  6223:    decode to ILVOD_W using decoder 268
                                             //  6223:   }
  31, 0,                                     //  6228:   case 0x1f: {
  OPC_CheckPredicate, 30,                    //  6230:    check predicate 30
  OPC_Decode, 160, 14, 141, 2,               //  6232:    decode to ILVOD_D using decoder 269
                                             //  6232:   }
                                             //  6232:   } // switch Inst[25:21]
                                             //  6232:  }
  21, 219, 1,                                //  6237:  case 0x15: {
  OPC_SwitchField, 21, 5,                    //  6240:   switch Inst[25:21] {
  0, 7,                                      //  6243:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  6245:    check predicate 30
  OPC_Decode, 205, 22, 142, 2,               //  6247:    decode to VSHF_B using decoder 270
                                             //  6247:   }
  1, 7,                                      //  6252:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  6254:    check predicate 30
  OPC_Decode, 207, 22, 143, 2,               //  6256:    decode to VSHF_H using decoder 271
                                             //  6256:   }
  2, 7,                                      //  6261:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  6263:    check predicate 30
  OPC_Decode, 208, 22, 144, 2,               //  6265:    decode to VSHF_W using decoder 272
                                             //  6265:   }
  3, 7,                                      //  6270:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  6272:    check predicate 30
  OPC_Decode, 206, 22, 145, 2,               //  6274:    decode to VSHF_D using decoder 273
                                             //  6274:   }
  4, 7,                                      //  6279:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  6281:    check predicate 30
  OPC_Decode, 233, 20, 138, 2,               //  6283:    decode to SRAR_B using decoder 266
                                             //  6283:   }
  5, 7,                                      //  6288:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  6290:    check predicate 30
  OPC_Decode, 235, 20, 139, 2,               //  6292:    decode to SRAR_H using decoder 267
                                             //  6292:   }
  6, 7,                                      //  6297:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  6299:    check predicate 30
  OPC_Decode, 236, 20, 140, 2,               //  6301:    decode to SRAR_W using decoder 268
                                             //  6301:   }
  7, 7,                                      //  6306:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  6308:    check predicate 30
  OPC_Decode, 234, 20, 141, 2,               //  6310:    decode to SRAR_D using decoder 269
                                             //  6310:   }
  8, 7,                                      //  6315:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  6317:    check predicate 30
  OPC_Decode, 255, 20, 138, 2,               //  6319:    decode to SRLR_B using decoder 266
                                             //  6319:   }
  9, 7,                                      //  6324:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  6326:    check predicate 30
  OPC_Decode, 129, 21, 139, 2,               //  6328:    decode to SRLR_H using decoder 267
                                             //  6328:   }
  10, 7,                                     //  6333:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  6335:    check predicate 30
  OPC_Decode, 130, 21, 140, 2,               //  6337:    decode to SRLR_W using decoder 268
                                             //  6337:   }
  11, 7,                                     //  6342:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  6344:    check predicate 30
  OPC_Decode, 128, 21, 141, 2,               //  6346:    decode to SRLR_D using decoder 269
                                             //  6346:   }
  17, 7,                                     //  6351:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  6353:    check predicate 30
  OPC_Decode, 138, 14, 146, 2,               //  6355:    decode to HADD_S_H using decoder 274
                                             //  6355:   }
  18, 7,                                     //  6360:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  6362:    check predicate 30
  OPC_Decode, 139, 14, 147, 2,               //  6364:    decode to HADD_S_W using decoder 275
                                             //  6364:   }
  19, 7,                                     //  6369:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  6371:    check predicate 30
  OPC_Decode, 137, 14, 148, 2,               //  6373:    decode to HADD_S_D using decoder 276
                                             //  6373:   }
  21, 7,                                     //  6378:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  6380:    check predicate 30
  OPC_Decode, 141, 14, 146, 2,               //  6382:    decode to HADD_U_H using decoder 274
                                             //  6382:   }
  22, 7,                                     //  6387:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  6389:    check predicate 30
  OPC_Decode, 142, 14, 147, 2,               //  6391:    decode to HADD_U_W using decoder 275
                                             //  6391:   }
  23, 7,                                     //  6396:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  6398:    check predicate 30
  OPC_Decode, 140, 14, 148, 2,               //  6400:    decode to HADD_U_D using decoder 276
                                             //  6400:   }
  25, 7,                                     //  6405:   case 0x19: {
  OPC_CheckPredicate, 30,                    //  6407:    check predicate 30
  OPC_Decode, 144, 14, 146, 2,               //  6409:    decode to HSUB_S_H using decoder 274
                                             //  6409:   }
  26, 7,                                     //  6414:   case 0x1a: {
  OPC_CheckPredicate, 30,                    //  6416:    check predicate 30
  OPC_Decode, 145, 14, 147, 2,               //  6418:    decode to HSUB_S_W using decoder 275
                                             //  6418:   }
  27, 7,                                     //  6423:   case 0x1b: {
  OPC_CheckPredicate, 30,                    //  6425:    check predicate 30
  OPC_Decode, 143, 14, 148, 2,               //  6427:    decode to HSUB_S_D using decoder 276
                                             //  6427:   }
  29, 7,                                     //  6432:   case 0x1d: {
  OPC_CheckPredicate, 30,                    //  6434:    check predicate 30
  OPC_Decode, 147, 14, 146, 2,               //  6436:    decode to HSUB_U_H using decoder 274
                                             //  6436:   }
  30, 7,                                     //  6441:   case 0x1e: {
  OPC_CheckPredicate, 30,                    //  6443:    check predicate 30
  OPC_Decode, 148, 14, 147, 2,               //  6445:    decode to HSUB_U_W using decoder 275
                                             //  6445:   }
  31, 0,                                     //  6450:   case 0x1f: {
  OPC_CheckPredicate, 30,                    //  6452:    check predicate 30
  OPC_Decode, 146, 14, 148, 2,               //  6454:    decode to HSUB_U_D using decoder 276
                                             //  6454:   }
                                             //  6454:   } // switch Inst[25:21]
                                             //  6454:  }
  25, 194, 2,                                //  6459:  case 0x19: {
  OPC_SwitchField, 20, 6,                    //  6462:   switch Inst[25:20] {
  0, 7,                                      //  6465:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  6467:    check predicate 30
  OPC_Decode, 177, 20, 160, 2,               //  6469:    decode to SLDI_B using decoder 288
                                             //  6469:   }
  2, 11,                                     //  6474:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  6476:    check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  6478:    check Inst[19] == 0x0
  OPC_Decode, 179, 20, 161, 2,               //  6482:    decode to SLDI_H using decoder 289
                                             //  6482:   }
  3, 38,                                     //  6487:   case 0x3: {
  OPC_SwitchField, 18, 2,                    //  6489:    switch Inst[19:18] {
  0, 7,                                      //  6492:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  6494:     check predicate 30
  OPC_Decode, 180, 20, 162, 2,               //  6496:     decode to SLDI_W using decoder 290
                                             //  6496:    }
  2, 11,                                     //  6501:    case 0x2: {
  OPC_CheckPredicate, 30,                    //  6503:     check predicate 30
  OPC_CheckField, 17, 1, 0,                  //  6505:     check Inst[17] == 0x0
  OPC_Decode, 178, 20, 163, 2,               //  6509:     decode to SLDI_D using decoder 291
                                             //  6509:    }
  3, 0,                                      //  6514:    case 0x3: {
  OPC_CheckPredicate, 30,                    //  6516:     check predicate 30
  OPC_CheckField, 16, 2, 2,                  //  6518:     check Inst[17:16] == 0x2
  OPC_Decode, 146, 10, 164, 2,               //  6522:     decode to CTCMSA using decoder 292
                                             //  6522:    }
                                             //  6522:    } // switch Inst[19:18]
                                             //  6522:   }
  4, 7,                                      //  6527:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  6529:    check predicate 30
  OPC_Decode, 216, 20, 165, 2,               //  6531:    decode to SPLATI_B using decoder 293
                                             //  6531:   }
  6, 11,                                     //  6536:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  6538:    check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  6540:    check Inst[19] == 0x0
  OPC_Decode, 218, 20, 166, 2,               //  6544:    decode to SPLATI_H using decoder 294
                                             //  6544:   }
  7, 38,                                     //  6549:   case 0x7: {
  OPC_SwitchField, 18, 2,                    //  6551:    switch Inst[19:18] {
  0, 7,                                      //  6554:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  6556:     check predicate 30
  OPC_Decode, 219, 20, 167, 2,               //  6558:     decode to SPLATI_W using decoder 295
                                             //  6558:    }
  2, 11,                                     //  6563:    case 0x2: {
  OPC_CheckPredicate, 30,                    //  6565:     check predicate 30
  OPC_CheckField, 17, 1, 0,                  //  6567:     check Inst[17] == 0x0
  OPC_Decode, 217, 20, 168, 2,               //  6571:     decode to SPLATI_D using decoder 296
                                             //  6571:    }
  3, 0,                                      //  6576:    case 0x3: {
  OPC_CheckPredicate, 30,                    //  6578:     check predicate 30
  OPC_CheckField, 16, 2, 2,                  //  6580:     check Inst[17:16] == 0x2
  OPC_Decode, 247, 8, 169, 2,                //  6584:     decode to CFCMSA using decoder 297
                                             //  6584:    }
                                             //  6584:    } // switch Inst[19:18]
                                             //  6584:   }
  8, 7,                                      //  6589:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  6591:    check predicate 30
  OPC_Decode, 128, 10, 170, 2,               //  6593:    decode to COPY_S_B using decoder 298
                                             //  6593:   }
  10, 11,                                    //  6598:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  6600:    check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  6602:    check Inst[19] == 0x0
  OPC_Decode, 130, 10, 171, 2,               //  6606:    decode to COPY_S_H using decoder 299
                                             //  6606:   }
  11, 38,                                    //  6611:   case 0xb: {
  OPC_SwitchField, 18, 2,                    //  6613:    switch Inst[19:18] {
  0, 7,                                      //  6616:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  6618:     check predicate 30
  OPC_Decode, 131, 10, 172, 2,               //  6620:     decode to COPY_S_W using decoder 300
                                             //  6620:    }
  2, 11,                                     //  6625:    case 0x2: {
  OPC_CheckPredicate, 38,                    //  6627:     check predicate 38
  OPC_CheckField, 17, 1, 0,                  //  6629:     check Inst[17] == 0x0
  OPC_Decode, 129, 10, 173, 2,               //  6633:     decode to COPY_S_D using decoder 301
                                             //  6633:    }
  3, 0,                                      //  6638:    case 0x3: {
  OPC_CheckPredicate, 30,                    //  6640:     check predicate 30
  OPC_CheckField, 16, 2, 2,                  //  6642:     check Inst[17:16] == 0x2
  OPC_Decode, 232, 16, 174, 2,               //  6646:     decode to MOVE_V using decoder 302
                                             //  6646:    }
                                             //  6646:    } // switch Inst[19:18]
                                             //  6646:   }
  12, 7,                                     //  6651:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  6653:    check predicate 30
  OPC_Decode, 132, 10, 170, 2,               //  6655:    decode to COPY_U_B using decoder 298
                                             //  6655:   }
  14, 11,                                    //  6660:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  6662:    check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  6664:    check Inst[19] == 0x0
  OPC_Decode, 133, 10, 171, 2,               //  6668:    decode to COPY_U_H using decoder 299
                                             //  6668:   }
  15, 11,                                    //  6673:   case 0xf: {
  OPC_CheckPredicate, 38,                    //  6675:    check predicate 38
  OPC_CheckField, 18, 2, 0,                  //  6677:    check Inst[19:18] == 0x0
  OPC_Decode, 134, 10, 172, 2,               //  6681:    decode to COPY_U_W using decoder 300
                                             //  6681:   }
  16, 7,                                     //  6686:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  6688:    check predicate 30
  OPC_Decode, 168, 14, 175, 2,               //  6690:    decode to INSERT_B using decoder 303
                                             //  6690:   }
  18, 11,                                    //  6695:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  6697:    check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  6699:    check Inst[19] == 0x0
  OPC_Decode, 170, 14, 176, 2,               //  6703:    decode to INSERT_H using decoder 304
                                             //  6703:   }
  19, 25,                                    //  6708:   case 0x13: {
  OPC_SwitchField, 18, 2,                    //  6710:    switch Inst[19:18] {
  0, 7,                                      //  6713:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  6715:     check predicate 30
  OPC_Decode, 171, 14, 177, 2,               //  6717:     decode to INSERT_W using decoder 305
                                             //  6717:    }
  2, 0,                                      //  6722:    case 0x2: {
  OPC_CheckPredicate, 38,                    //  6724:     check predicate 38
  OPC_CheckField, 17, 1, 0,                  //  6726:     check Inst[17] == 0x0
  OPC_Decode, 169, 14, 178, 2,               //  6730:     decode to INSERT_D using decoder 306
                                             //  6730:    }
                                             //  6730:    } // switch Inst[19:18]
                                             //  6730:   }
  20, 7,                                     //  6735:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  6737:    check predicate 30
  OPC_Decode, 173, 14, 179, 2,               //  6739:    decode to INSVE_B using decoder 307
                                             //  6739:   }
  22, 11,                                    //  6744:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  6746:    check predicate 30
  OPC_CheckField, 19, 1, 0,                  //  6748:    check Inst[19] == 0x0
  OPC_Decode, 175, 14, 179, 2,               //  6752:    decode to INSVE_H using decoder 307
                                             //  6752:   }
  23, 0,                                     //  6757:   case 0x17: {
  OPC_SwitchField, 18, 2,                    //  6759:    switch Inst[19:18] {
  0, 7,                                      //  6762:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  6764:     check predicate 30
  OPC_Decode, 176, 14, 179, 2,               //  6766:     decode to INSVE_W using decoder 307
                                             //  6766:    }
  2, 0,                                      //  6771:    case 0x2: {
  OPC_CheckPredicate, 30,                    //  6773:     check predicate 30
  OPC_CheckField, 17, 1, 0,                  //  6775:     check Inst[17] == 0x0
  OPC_Decode, 174, 14, 179, 2,               //  6779:     decode to INSVE_D using decoder 307
                                             //  6779:    }
                                             //  6779:    } // switch Inst[19:18]
                                             //  6779:   }
                                             //  6779:   } // switch Inst[25:20]
                                             //  6779:  }
  26, 163, 2,                                //  6784:  case 0x1a: {
  OPC_SwitchField, 21, 5,                    //  6787:   switch Inst[25:21] {
  0, 7,                                      //  6790:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  6792:    check predicate 30
  OPC_Decode, 225, 12, 140, 2,               //  6794:    decode to FCAF_W using decoder 268
                                             //  6794:   }
  1, 7,                                      //  6799:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  6801:    check predicate 30
  OPC_Decode, 224, 12, 141, 2,               //  6803:    decode to FCAF_D using decoder 269
                                             //  6803:   }
  2, 7,                                      //  6808:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  6810:    check predicate 30
  OPC_Decode, 252, 12, 140, 2,               //  6812:    decode to FCUN_W using decoder 268
                                             //  6812:   }
  3, 7,                                      //  6817:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  6819:    check predicate 30
  OPC_Decode, 251, 12, 141, 2,               //  6821:    decode to FCUN_D using decoder 269
                                             //  6821:   }
  4, 7,                                      //  6826:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  6828:    check predicate 30
  OPC_Decode, 227, 12, 140, 2,               //  6830:    decode to FCEQ_W using decoder 268
                                             //  6830:   }
  5, 7,                                      //  6835:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  6837:    check predicate 30
  OPC_Decode, 226, 12, 141, 2,               //  6839:    decode to FCEQ_D using decoder 269
                                             //  6839:   }
  6, 7,                                      //  6844:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  6846:    check predicate 30
  OPC_Decode, 244, 12, 140, 2,               //  6848:    decode to FCUEQ_W using decoder 268
                                             //  6848:   }
  7, 7,                                      //  6853:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  6855:    check predicate 30
  OPC_Decode, 243, 12, 141, 2,               //  6857:    decode to FCUEQ_D using decoder 269
                                             //  6857:   }
  8, 7,                                      //  6862:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  6864:    check predicate 30
  OPC_Decode, 233, 12, 140, 2,               //  6866:    decode to FCLT_W using decoder 268
                                             //  6866:   }
  9, 7,                                      //  6871:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  6873:    check predicate 30
  OPC_Decode, 232, 12, 141, 2,               //  6875:    decode to FCLT_D using decoder 269
                                             //  6875:   }
  10, 7,                                     //  6880:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  6882:    check predicate 30
  OPC_Decode, 248, 12, 140, 2,               //  6884:    decode to FCULT_W using decoder 268
                                             //  6884:   }
  11, 7,                                     //  6889:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  6891:    check predicate 30
  OPC_Decode, 247, 12, 141, 2,               //  6893:    decode to FCULT_D using decoder 269
                                             //  6893:   }
  12, 7,                                     //  6898:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  6900:    check predicate 30
  OPC_Decode, 231, 12, 140, 2,               //  6902:    decode to FCLE_W using decoder 268
                                             //  6902:   }
  13, 7,                                     //  6907:   case 0xd: {
  OPC_CheckPredicate, 30,                    //  6909:    check predicate 30
  OPC_Decode, 230, 12, 141, 2,               //  6911:    decode to FCLE_D using decoder 269
                                             //  6911:   }
  14, 7,                                     //  6916:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  6918:    check predicate 30
  OPC_Decode, 246, 12, 140, 2,               //  6920:    decode to FCULE_W using decoder 268
                                             //  6920:   }
  15, 7,                                     //  6925:   case 0xf: {
  OPC_CheckPredicate, 30,                    //  6927:    check predicate 30
  OPC_Decode, 245, 12, 141, 2,               //  6929:    decode to FCULE_D using decoder 269
                                             //  6929:   }
  16, 7,                                     //  6934:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  6936:    check predicate 30
  OPC_Decode, 212, 13, 140, 2,               //  6938:    decode to FSAF_W using decoder 268
                                             //  6938:   }
  17, 7,                                     //  6943:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  6945:    check predicate 30
  OPC_Decode, 211, 13, 141, 2,               //  6947:    decode to FSAF_D using decoder 269
                                             //  6947:   }
  18, 7,                                     //  6952:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  6954:    check predicate 30
  OPC_Decode, 250, 13, 140, 2,               //  6956:    decode to FSUN_W using decoder 268
                                             //  6956:   }
  19, 7,                                     //  6961:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  6963:    check predicate 30
  OPC_Decode, 249, 13, 141, 2,               //  6965:    decode to FSUN_D using decoder 269
                                             //  6965:   }
  20, 7,                                     //  6970:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  6972:    check predicate 30
  OPC_Decode, 214, 13, 140, 2,               //  6974:    decode to FSEQ_W using decoder 268
                                             //  6974:   }
  21, 7,                                     //  6979:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  6981:    check predicate 30
  OPC_Decode, 213, 13, 141, 2,               //  6983:    decode to FSEQ_D using decoder 269
                                             //  6983:   }
  22, 7,                                     //  6988:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  6990:    check predicate 30
  OPC_Decode, 242, 13, 140, 2,               //  6992:    decode to FSUEQ_W using decoder 268
                                             //  6992:   }
  23, 7,                                     //  6997:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  6999:    check predicate 30
  OPC_Decode, 241, 13, 141, 2,               //  7001:    decode to FSUEQ_D using decoder 269
                                             //  7001:   }
  24, 7,                                     //  7006:   case 0x18: {
  OPC_CheckPredicate, 30,                    //  7008:    check predicate 30
  OPC_Decode, 218, 13, 140, 2,               //  7010:    decode to FSLT_W using decoder 268
                                             //  7010:   }
  25, 7,                                     //  7015:   case 0x19: {
  OPC_CheckPredicate, 30,                    //  7017:    check predicate 30
  OPC_Decode, 217, 13, 141, 2,               //  7019:    decode to FSLT_D using decoder 269
                                             //  7019:   }
  26, 7,                                     //  7024:   case 0x1a: {
  OPC_CheckPredicate, 30,                    //  7026:    check predicate 30
  OPC_Decode, 246, 13, 140, 2,               //  7028:    decode to FSULT_W using decoder 268
                                             //  7028:   }
  27, 7,                                     //  7033:   case 0x1b: {
  OPC_CheckPredicate, 30,                    //  7035:    check predicate 30
  OPC_Decode, 245, 13, 141, 2,               //  7037:    decode to FSULT_D using decoder 269
                                             //  7037:   }
  28, 7,                                     //  7042:   case 0x1c: {
  OPC_CheckPredicate, 30,                    //  7044:    check predicate 30
  OPC_Decode, 216, 13, 140, 2,               //  7046:    decode to FSLE_W using decoder 268
                                             //  7046:   }
  29, 7,                                     //  7051:   case 0x1d: {
  OPC_CheckPredicate, 30,                    //  7053:    check predicate 30
  OPC_Decode, 215, 13, 141, 2,               //  7055:    decode to FSLE_D using decoder 269
                                             //  7055:   }
  30, 7,                                     //  7060:   case 0x1e: {
  OPC_CheckPredicate, 30,                    //  7062:    check predicate 30
  OPC_Decode, 244, 13, 140, 2,               //  7064:    decode to FSULE_W using decoder 268
                                             //  7064:   }
  31, 0,                                     //  7069:   case 0x1f: {
  OPC_CheckPredicate, 30,                    //  7071:    check predicate 30
  OPC_Decode, 243, 13, 141, 2,               //  7073:    decode to FSULE_D using decoder 269
                                             //  7073:   }
                                             //  7073:   } // switch Inst[25:21]
                                             //  7073:  }
  27, 237, 1,                                //  7078:  case 0x1b: {
  OPC_SwitchField, 21, 5,                    //  7081:   switch Inst[25:21] {
  0, 7,                                      //  7084:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  7086:    check predicate 30
  OPC_Decode, 223, 12, 140, 2,               //  7088:    decode to FADD_W using decoder 268
                                             //  7088:   }
  1, 7,                                      //  7093:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  7095:    check predicate 30
  OPC_Decode, 214, 12, 141, 2,               //  7097:    decode to FADD_D using decoder 269
                                             //  7097:   }
  2, 7,                                      //  7102:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  7104:    check predicate 30
  OPC_Decode, 240, 13, 140, 2,               //  7106:    decode to FSUB_W using decoder 268
                                             //  7106:   }
  3, 7,                                      //  7111:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  7113:    check predicate 30
  OPC_Decode, 231, 13, 141, 2,               //  7115:    decode to FSUB_D using decoder 269
                                             //  7115:   }
  4, 7,                                      //  7120:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  7122:    check predicate 30
  OPC_Decode, 196, 13, 140, 2,               //  7124:    decode to FMUL_W using decoder 268
                                             //  7124:   }
  5, 7,                                      //  7129:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  7131:    check predicate 30
  OPC_Decode, 187, 13, 141, 2,               //  7133:    decode to FMUL_D using decoder 269
                                             //  7133:   }
  6, 7,                                      //  7138:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  7140:    check predicate 30
  OPC_Decode, 133, 13, 140, 2,               //  7142:    decode to FDIV_W using decoder 268
                                             //  7142:   }
  7, 7,                                      //  7147:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  7149:    check predicate 30
  OPC_Decode, 253, 12, 141, 2,               //  7151:    decode to FDIV_D using decoder 269
                                             //  7151:   }
  8, 7,                                      //  7156:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  7158:    check predicate 30
  OPC_Decode, 168, 13, 144, 2,               //  7160:    decode to FMADD_W using decoder 272
                                             //  7160:   }
  9, 7,                                      //  7165:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  7167:    check predicate 30
  OPC_Decode, 167, 13, 145, 2,               //  7169:    decode to FMADD_D using decoder 273
                                             //  7169:   }
  10, 7,                                     //  7174:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  7176:    check predicate 30
  OPC_Decode, 186, 13, 144, 2,               //  7178:    decode to FMSUB_W using decoder 272
                                             //  7178:   }
  11, 7,                                     //  7183:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  7185:    check predicate 30
  OPC_Decode, 185, 13, 145, 2,               //  7187:    decode to FMSUB_D using decoder 273
                                             //  7187:   }
  14, 7,                                     //  7192:   case 0xe: {
  OPC_CheckPredicate, 30,                    //  7194:    check predicate 30
  OPC_Decode, 137, 13, 140, 2,               //  7196:    decode to FEXP2_W using decoder 268
                                             //  7196:   }
  15, 7,                                     //  7201:   case 0xf: {
  OPC_CheckPredicate, 30,                    //  7203:    check predicate 30
  OPC_Decode, 136, 13, 141, 2,               //  7205:    decode to FEXP2_D using decoder 269
                                             //  7205:   }
  16, 7,                                     //  7210:   case 0x10: {
  OPC_CheckPredicate, 30,                    //  7212:    check predicate 30
  OPC_Decode, 134, 13, 180, 2,               //  7214:    decode to FEXDO_H using decoder 308
                                             //  7214:   }
  17, 7,                                     //  7219:   case 0x11: {
  OPC_CheckPredicate, 30,                    //  7221:    check predicate 30
  OPC_Decode, 135, 13, 181, 2,               //  7223:    decode to FEXDO_W using decoder 309
                                             //  7223:   }
  20, 7,                                     //  7228:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  7230:    check predicate 30
  OPC_Decode, 255, 13, 180, 2,               //  7232:    decode to FTQ_H using decoder 308
                                             //  7232:   }
  21, 7,                                     //  7237:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  7239:    check predicate 30
  OPC_Decode, 128, 14, 181, 2,               //  7241:    decode to FTQ_W using decoder 309
                                             //  7241:   }
  24, 7,                                     //  7246:   case 0x18: {
  OPC_CheckPredicate, 30,                    //  7248:    check predicate 30
  OPC_Decode, 176, 13, 140, 2,               //  7250:    decode to FMIN_W using decoder 268
                                             //  7250:   }
  25, 7,                                     //  7255:   case 0x19: {
  OPC_CheckPredicate, 30,                    //  7257:    check predicate 30
  OPC_Decode, 175, 13, 141, 2,               //  7259:    decode to FMIN_D using decoder 269
                                             //  7259:   }
  26, 7,                                     //  7264:   case 0x1a: {
  OPC_CheckPredicate, 30,                    //  7266:    check predicate 30
  OPC_Decode, 174, 13, 140, 2,               //  7268:    decode to FMIN_A_W using decoder 268
                                             //  7268:   }
  27, 7,                                     //  7273:   case 0x1b: {
  OPC_CheckPredicate, 30,                    //  7275:    check predicate 30
  OPC_Decode, 173, 13, 141, 2,               //  7277:    decode to FMIN_A_D using decoder 269
                                             //  7277:   }
  28, 7,                                     //  7282:   case 0x1c: {
  OPC_CheckPredicate, 30,                    //  7284:    check predicate 30
  OPC_Decode, 172, 13, 140, 2,               //  7286:    decode to FMAX_W using decoder 268
                                             //  7286:   }
  29, 7,                                     //  7291:   case 0x1d: {
  OPC_CheckPredicate, 30,                    //  7293:    check predicate 30
  OPC_Decode, 171, 13, 141, 2,               //  7295:    decode to FMAX_D using decoder 269
                                             //  7295:   }
  30, 7,                                     //  7300:   case 0x1e: {
  OPC_CheckPredicate, 30,                    //  7302:    check predicate 30
  OPC_Decode, 170, 13, 140, 2,               //  7304:    decode to FMAX_A_W using decoder 268
                                             //  7304:   }
  31, 0,                                     //  7309:   case 0x1f: {
  OPC_CheckPredicate, 30,                    //  7311:    check predicate 30
  OPC_Decode, 169, 13, 141, 2,               //  7313:    decode to FMAX_A_D using decoder 269
                                             //  7313:   }
                                             //  7313:   } // switch Inst[25:21]
                                             //  7313:  }
  28, 219, 1,                                //  7318:  case 0x1c: {
  OPC_SwitchField, 21, 5,                    //  7321:   switch Inst[25:21] {
  2, 7,                                      //  7324:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  7326:    check predicate 30
  OPC_Decode, 242, 12, 140, 2,               //  7328:    decode to FCOR_W using decoder 268
                                             //  7328:   }
  3, 7,                                      //  7333:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  7335:    check predicate 30
  OPC_Decode, 241, 12, 141, 2,               //  7337:    decode to FCOR_D using decoder 269
                                             //  7337:   }
  4, 7,                                      //  7342:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  7344:    check predicate 30
  OPC_Decode, 250, 12, 140, 2,               //  7346:    decode to FCUNE_W using decoder 268
                                             //  7346:   }
  5, 7,                                      //  7351:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  7353:    check predicate 30
  OPC_Decode, 249, 12, 141, 2,               //  7355:    decode to FCUNE_D using decoder 269
                                             //  7355:   }
  6, 7,                                      //  7360:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  7362:    check predicate 30
  OPC_Decode, 240, 12, 140, 2,               //  7364:    decode to FCNE_W using decoder 268
                                             //  7364:   }
  7, 7,                                      //  7369:   case 0x7: {
  OPC_CheckPredicate, 30,                    //  7371:    check predicate 30
  OPC_Decode, 239, 12, 141, 2,               //  7373:    decode to FCNE_D using decoder 269
                                             //  7373:   }
  8, 7,                                      //  7378:   case 0x8: {
  OPC_CheckPredicate, 30,                    //  7380:    check predicate 30
  OPC_Decode, 254, 17, 139, 2,               //  7382:    decode to MUL_Q_H using decoder 267
                                             //  7382:   }
  9, 7,                                      //  7387:   case 0x9: {
  OPC_CheckPredicate, 30,                    //  7389:    check predicate 30
  OPC_Decode, 255, 17, 140, 2,               //  7391:    decode to MUL_Q_W using decoder 268
                                             //  7391:   }
  10, 7,                                     //  7396:   case 0xa: {
  OPC_CheckPredicate, 30,                    //  7398:    check predicate 30
  OPC_Decode, 243, 15, 143, 2,               //  7400:    decode to MADD_Q_H using decoder 271
                                             //  7400:   }
  11, 7,                                     //  7405:   case 0xb: {
  OPC_CheckPredicate, 30,                    //  7407:    check predicate 30
  OPC_Decode, 244, 15, 144, 2,               //  7409:    decode to MADD_Q_W using decoder 272
                                             //  7409:   }
  12, 7,                                     //  7414:   case 0xc: {
  OPC_CheckPredicate, 30,                    //  7416:    check predicate 30
  OPC_Decode, 166, 17, 143, 2,               //  7418:    decode to MSUB_Q_H using decoder 271
                                             //  7418:   }
  13, 7,                                     //  7423:   case 0xd: {
  OPC_CheckPredicate, 30,                    //  7425:    check predicate 30
  OPC_Decode, 167, 17, 144, 2,               //  7427:    decode to MSUB_Q_W using decoder 272
                                             //  7427:   }
  18, 7,                                     //  7432:   case 0x12: {
  OPC_CheckPredicate, 30,                    //  7434:    check predicate 30
  OPC_Decode, 222, 13, 140, 2,               //  7436:    decode to FSOR_W using decoder 268
                                             //  7436:   }
  19, 7,                                     //  7441:   case 0x13: {
  OPC_CheckPredicate, 30,                    //  7443:    check predicate 30
  OPC_Decode, 221, 13, 141, 2,               //  7445:    decode to FSOR_D using decoder 269
                                             //  7445:   }
  20, 7,                                     //  7450:   case 0x14: {
  OPC_CheckPredicate, 30,                    //  7452:    check predicate 30
  OPC_Decode, 248, 13, 140, 2,               //  7454:    decode to FSUNE_W using decoder 268
                                             //  7454:   }
  21, 7,                                     //  7459:   case 0x15: {
  OPC_CheckPredicate, 30,                    //  7461:    check predicate 30
  OPC_Decode, 247, 13, 141, 2,               //  7463:    decode to FSUNE_D using decoder 269
                                             //  7463:   }
  22, 7,                                     //  7468:   case 0x16: {
  OPC_CheckPredicate, 30,                    //  7470:    check predicate 30
  OPC_Decode, 220, 13, 140, 2,               //  7472:    decode to FSNE_W using decoder 268
                                             //  7472:   }
  23, 7,                                     //  7477:   case 0x17: {
  OPC_CheckPredicate, 30,                    //  7479:    check predicate 30
  OPC_Decode, 219, 13, 141, 2,               //  7481:    decode to FSNE_D using decoder 269
                                             //  7481:   }
  24, 7,                                     //  7486:   case 0x18: {
  OPC_CheckPredicate, 30,                    //  7488:    check predicate 30
  OPC_Decode, 230, 17, 139, 2,               //  7490:    decode to MULR_Q_H using decoder 267
                                             //  7490:   }
  25, 7,                                     //  7495:   case 0x19: {
  OPC_CheckPredicate, 30,                    //  7497:    check predicate 30
  OPC_Decode, 231, 17, 140, 2,               //  7499:    decode to MULR_Q_W using decoder 268
                                             //  7499:   }
  26, 7,                                     //  7504:   case 0x1a: {
  OPC_CheckPredicate, 30,                    //  7506:    check predicate 30
  OPC_Decode, 227, 15, 143, 2,               //  7508:    decode to MADDR_Q_H using decoder 271
                                             //  7508:   }
  27, 7,                                     //  7513:   case 0x1b: {
  OPC_CheckPredicate, 30,                    //  7515:    check predicate 30
  OPC_Decode, 228, 15, 144, 2,               //  7517:    decode to MADDR_Q_W using decoder 272
                                             //  7517:   }
  28, 7,                                     //  7522:   case 0x1c: {
  OPC_CheckPredicate, 30,                    //  7524:    check predicate 30
  OPC_Decode, 150, 17, 143, 2,               //  7526:    decode to MSUBR_Q_H using decoder 271
                                             //  7526:   }
  29, 0,                                     //  7531:   case 0x1d: {
  OPC_CheckPredicate, 30,                    //  7533:    check predicate 30
  OPC_Decode, 151, 17, 144, 2,               //  7535:    decode to MSUBR_Q_W using decoder 272
                                             //  7535:   }
                                             //  7535:   } // switch Inst[25:21]
                                             //  7535:  }
  30, 253, 3,                                //  7540:  case 0x1e: {
  OPC_SwitchField, 21, 5,                    //  7543:   switch Inst[25:21] {
  0, 7,                                      //  7546:   case 0x0: {
  OPC_CheckPredicate, 30,                    //  7548:    check predicate 30
  OPC_Decode, 235, 6, 138, 2,                //  7550:    decode to AND_V using decoder 266
                                             //  7550:   }
  1, 7,                                      //  7555:   case 0x1: {
  OPC_CheckPredicate, 30,                    //  7557:    check predicate 30
  OPC_Decode, 172, 18, 138, 2,               //  7559:    decode to OR_V using decoder 266
                                             //  7559:   }
  2, 7,                                      //  7564:   case 0x2: {
  OPC_CheckPredicate, 30,                    //  7566:    check predicate 30
  OPC_Decode, 159, 18, 138, 2,               //  7568:    decode to NOR_V using decoder 266
                                             //  7568:   }
  3, 7,                                      //  7573:   case 0x3: {
  OPC_CheckPredicate, 30,                    //  7575:    check predicate 30
  OPC_Decode, 226, 22, 138, 2,               //  7577:    decode to XOR_V using decoder 266
                                             //  7577:   }
  4, 7,                                      //  7582:   case 0x4: {
  OPC_CheckPredicate, 30,                    //  7584:    check predicate 30
  OPC_Decode, 150, 8, 142, 2,                //  7586:    decode to BMNZ_V using decoder 270
                                             //  7586:   }
  5, 7,                                      //  7591:   case 0x5: {
  OPC_CheckPredicate, 30,                    //  7593:    check predicate 30
  OPC_Decode, 152, 8, 142, 2,                //  7595:    decode to BMZ_V using decoder 270
                                             //  7595:   }
  6, 7,                                      //  7600:   case 0x6: {
  OPC_CheckPredicate, 30,                    //  7602:    check predicate 30
  OPC_Decode, 194, 8, 142, 2,                //  7604:    decode to BSEL_V using decoder 270
                                             //  7604:   }
  24, 147, 1,                                //  7609:   case 0x18: {
  OPC_SwitchField, 16, 5,                    //  7612:    switch Inst[20:16] {
  0, 7,                                      //  7615:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  7617:     check predicate 30
  OPC_Decode, 150, 13, 182, 2,               //  7619:     decode to FILL_B using decoder 310
                                             //  7619:    }
  1, 7,                                      //  7624:    case 0x1: {
  OPC_CheckPredicate, 30,                    //  7626:     check predicate 30
  OPC_Decode, 152, 13, 183, 2,               //  7628:     decode to FILL_H using decoder 311
                                             //  7628:    }
  2, 7,                                      //  7633:    case 0x2: {
  OPC_CheckPredicate, 30,                    //  7635:     check predicate 30
  OPC_Decode, 153, 13, 184, 2,               //  7637:     decode to FILL_W using decoder 312
                                             //  7637:    }
  3, 7,                                      //  7642:    case 0x3: {
  OPC_CheckPredicate, 38,                    //  7644:     check predicate 38
  OPC_Decode, 151, 13, 185, 2,               //  7646:     decode to FILL_D using decoder 313
                                             //  7646:    }
  4, 7,                                      //  7651:    case 0x4: {
  OPC_CheckPredicate, 30,                    //  7653:     check predicate 30
  OPC_Decode, 190, 18, 174, 2,               //  7655:     decode to PCNT_B using decoder 302
                                             //  7655:    }
  5, 7,                                      //  7660:    case 0x5: {
  OPC_CheckPredicate, 30,                    //  7662:     check predicate 30
  OPC_Decode, 192, 18, 186, 2,               //  7664:     decode to PCNT_H using decoder 314
                                             //  7664:    }
  6, 7,                                      //  7669:    case 0x6: {
  OPC_CheckPredicate, 30,                    //  7671:     check predicate 30
  OPC_Decode, 193, 18, 187, 2,               //  7673:     decode to PCNT_W using decoder 315
                                             //  7673:    }
  7, 7,                                      //  7678:    case 0x7: {
  OPC_CheckPredicate, 30,                    //  7680:     check predicate 30
  OPC_Decode, 191, 18, 188, 2,               //  7682:     decode to PCNT_D using decoder 316
                                             //  7682:    }
  8, 7,                                      //  7687:    case 0x8: {
  OPC_CheckPredicate, 30,                    //  7689:     check predicate 30
  OPC_Decode, 136, 18, 174, 2,               //  7691:     decode to NLOC_B using decoder 302
                                             //  7691:    }
  9, 7,                                      //  7696:    case 0x9: {
  OPC_CheckPredicate, 30,                    //  7698:     check predicate 30
  OPC_Decode, 138, 18, 186, 2,               //  7700:     decode to NLOC_H using decoder 314
                                             //  7700:    }
  10, 7,                                     //  7705:    case 0xa: {
  OPC_CheckPredicate, 30,                    //  7707:     check predicate 30
  OPC_Decode, 139, 18, 187, 2,               //  7709:     decode to NLOC_W using decoder 315
                                             //  7709:    }
  11, 7,                                     //  7714:    case 0xb: {
  OPC_CheckPredicate, 30,                    //  7716:     check predicate 30
  OPC_Decode, 137, 18, 188, 2,               //  7718:     decode to NLOC_D using decoder 316
                                             //  7718:    }
  12, 7,                                     //  7723:    case 0xc: {
  OPC_CheckPredicate, 30,                    //  7725:     check predicate 30
  OPC_Decode, 140, 18, 174, 2,               //  7727:     decode to NLZC_B using decoder 302
                                             //  7727:    }
  13, 7,                                     //  7732:    case 0xd: {
  OPC_CheckPredicate, 30,                    //  7734:     check predicate 30
  OPC_Decode, 142, 18, 186, 2,               //  7736:     decode to NLZC_H using decoder 314
                                             //  7736:    }
  14, 7,                                     //  7741:    case 0xe: {
  OPC_CheckPredicate, 30,                    //  7743:     check predicate 30
  OPC_Decode, 143, 18, 187, 2,               //  7745:     decode to NLZC_W using decoder 315
                                             //  7745:    }
  15, 0,                                     //  7750:    case 0xf: {
  OPC_CheckPredicate, 30,                    //  7752:     check predicate 30
  OPC_Decode, 141, 18, 188, 2,               //  7754:     decode to NLZC_D using decoder 316
                                             //  7754:    }
                                             //  7754:    } // switch Inst[20:16]
                                             //  7754:   }
  25, 0,                                     //  7759:   case 0x19: {
  OPC_SwitchField, 16, 5,                    //  7761:    switch Inst[20:16] {
  0, 7,                                      //  7764:    case 0x0: {
  OPC_CheckPredicate, 30,                    //  7766:     check predicate 30
  OPC_Decode, 229, 12, 187, 2,               //  7768:     decode to FCLASS_W using decoder 315
                                             //  7768:    }
  1, 7,                                      //  7773:    case 0x1: {
  OPC_CheckPredicate, 30,                    //  7775:     check predicate 30
  OPC_Decode, 228, 12, 188, 2,               //  7777:     decode to FCLASS_D using decoder 316
                                             //  7777:    }
  2, 7,                                      //  7782:    case 0x2: {
  OPC_CheckPredicate, 30,                    //  7784:     check predicate 30
  OPC_Decode, 130, 14, 187, 2,               //  7786:     decode to FTRUNC_S_W using decoder 315
                                             //  7786:    }
  3, 7,                                      //  7791:    case 0x3: {
  OPC_CheckPredicate, 30,                    //  7793:     check predicate 30
  OPC_Decode, 129, 14, 188, 2,               //  7795:     decode to FTRUNC_S_D using decoder 316
                                             //  7795:    }
  4, 7,                                      //  7800:    case 0x4: {
  OPC_CheckPredicate, 30,                    //  7802:     check predicate 30
  OPC_Decode, 132, 14, 187, 2,               //  7804:     decode to FTRUNC_U_W using decoder 315
                                             //  7804:    }
  5, 7,                                      //  7809:    case 0x5: {
  OPC_CheckPredicate, 30,                    //  7811:     check predicate 30
  OPC_Decode, 131, 14, 188, 2,               //  7813:     decode to FTRUNC_U_D using decoder 316
                                             //  7813:    }
  6, 7,                                      //  7818:    case 0x6: {
  OPC_CheckPredicate, 30,                    //  7820:     check predicate 30
  OPC_Decode, 230, 13, 187, 2,               //  7822:     decode to FSQRT_W using decoder 315
                                             //  7822:    }
  7, 7,                                      //  7827:    case 0x7: {
  OPC_CheckPredicate, 30,                    //  7829:     check predicate 30
  OPC_Decode, 223, 13, 188, 2,               //  7831:     decode to FSQRT_D using decoder 316
                                             //  7831:    }
  8, 7,                                      //  7836:    case 0x8: {
  OPC_CheckPredicate, 30,                    //  7838:     check predicate 30
  OPC_Decode, 210, 13, 187, 2,               //  7840:     decode to FRSQRT_W using decoder 315
                                             //  7840:    }
  9, 7,                                      //  7845:    case 0x9: {
  OPC_CheckPredicate, 30,                    //  7847:     check predicate 30
  OPC_Decode, 209, 13, 188, 2,               //  7849:     decode to FRSQRT_D using decoder 316
                                             //  7849:    }
  10, 7,                                     //  7854:    case 0xa: {
  OPC_CheckPredicate, 30,                    //  7856:     check predicate 30
  OPC_Decode, 206, 13, 187, 2,               //  7858:     decode to FRCP_W using decoder 315
                                             //  7858:    }
  11, 7,                                     //  7863:    case 0xb: {
  OPC_CheckPredicate, 30,                    //  7865:     check predicate 30
  OPC_Decode, 205, 13, 188, 2,               //  7867:     decode to FRCP_D using decoder 316
                                             //  7867:    }
  12, 7,                                     //  7872:    case 0xc: {
  OPC_CheckPredicate, 30,                    //  7874:     check predicate 30
  OPC_Decode, 208, 13, 187, 2,               //  7876:     decode to FRINT_W using decoder 315
                                             //  7876:    }
  13, 7,                                     //  7881:    case 0xd: {
  OPC_CheckPredicate, 30,                    //  7883:     check predicate 30
  OPC_Decode, 207, 13, 188, 2,               //  7885:     decode to FRINT_D using decoder 316
                                             //  7885:    }
  14, 7,                                     //  7890:    case 0xe: {
  OPC_CheckPredicate, 30,                    //  7892:     check predicate 30
  OPC_Decode, 155, 13, 187, 2,               //  7894:     decode to FLOG2_W using decoder 315
                                             //  7894:    }
  15, 7,                                     //  7899:    case 0xf: {
  OPC_CheckPredicate, 30,                    //  7901:     check predicate 30
  OPC_Decode, 154, 13, 188, 2,               //  7903:     decode to FLOG2_D using decoder 316
                                             //  7903:    }
  16, 7,                                     //  7908:    case 0x10: {
  OPC_CheckPredicate, 30,                    //  7910:     check predicate 30
  OPC_Decode, 139, 13, 189, 2,               //  7912:     decode to FEXUPL_W using decoder 317
                                             //  7912:    }
  17, 7,                                     //  7917:    case 0x11: {
  OPC_CheckPredicate, 30,                    //  7919:     check predicate 30
  OPC_Decode, 138, 13, 190, 2,               //  7921:     decode to FEXUPL_D using decoder 318
                                             //  7921:    }
  18, 7,                                     //  7926:    case 0x12: {
  OPC_CheckPredicate, 30,                    //  7928:     check predicate 30
  OPC_Decode, 141, 13, 189, 2,               //  7930:     decode to FEXUPR_W using decoder 317
                                             //  7930:    }
  19, 7,                                     //  7935:    case 0x13: {
  OPC_CheckPredicate, 30,                    //  7937:     check predicate 30
  OPC_Decode, 140, 13, 190, 2,               //  7939:     decode to FEXUPR_D using decoder 318
                                             //  7939:    }
  20, 7,                                     //  7944:    case 0x14: {
  OPC_CheckPredicate, 30,                    //  7946:     check predicate 30
  OPC_Decode, 147, 13, 189, 2,               //  7948:     decode to FFQL_W using decoder 317
                                             //  7948:    }
  21, 7,                                     //  7953:    case 0x15: {
  OPC_CheckPredicate, 30,                    //  7955:     check predicate 30
  OPC_Decode, 146, 13, 190, 2,               //  7957:     decode to FFQL_D using decoder 318
                                             //  7957:    }
  22, 7,                                     //  7962:    case 0x16: {
  OPC_CheckPredicate, 30,                    //  7964:     check predicate 30
  OPC_Decode, 149, 13, 189, 2,               //  7966:     decode to FFQR_W using decoder 317
                                             //  7966:    }
  23, 7,                                     //  7971:    case 0x17: {
  OPC_CheckPredicate, 30,                    //  7973:     check predicate 30
  OPC_Decode, 148, 13, 190, 2,               //  7975:     decode to FFQR_D using decoder 318
                                             //  7975:    }
  24, 7,                                     //  7980:    case 0x18: {
  OPC_CheckPredicate, 30,                    //  7982:     check predicate 30
  OPC_Decode, 252, 13, 187, 2,               //  7984:     decode to FTINT_S_W using decoder 315
                                             //  7984:    }
  25, 7,                                     //  7989:    case 0x19: {
  OPC_CheckPredicate, 30,                    //  7991:     check predicate 30
  OPC_Decode, 251, 13, 188, 2,               //  7993:     decode to FTINT_S_D using decoder 316
                                             //  7993:    }
  26, 7,                                     //  7998:    case 0x1a: {
  OPC_CheckPredicate, 30,                    //  8000:     check predicate 30
  OPC_Decode, 254, 13, 187, 2,               //  8002:     decode to FTINT_U_W using decoder 315
                                             //  8002:    }
  27, 7,                                     //  8007:    case 0x1b: {
  OPC_CheckPredicate, 30,                    //  8009:     check predicate 30
  OPC_Decode, 253, 13, 188, 2,               //  8011:     decode to FTINT_U_D using decoder 316
                                             //  8011:    }
  28, 7,                                     //  8016:    case 0x1c: {
  OPC_CheckPredicate, 30,                    //  8018:     check predicate 30
  OPC_Decode, 143, 13, 187, 2,               //  8020:     decode to FFINT_S_W using decoder 315
                                             //  8020:    }
  29, 7,                                     //  8025:    case 0x1d: {
  OPC_CheckPredicate, 30,                    //  8027:     check predicate 30
  OPC_Decode, 142, 13, 188, 2,               //  8029:     decode to FFINT_S_D using decoder 316
                                             //  8029:    }
  30, 7,                                     //  8034:    case 0x1e: {
  OPC_CheckPredicate, 30,                    //  8036:     check predicate 30
  OPC_Decode, 145, 13, 187, 2,               //  8038:     decode to FFINT_U_W using decoder 315
                                             //  8038:    }
  31, 0,                                     //  8043:    case 0x1f: {
  OPC_CheckPredicate, 30,                    //  8045:     check predicate 30
  OPC_Decode, 144, 13, 188, 2,               //  8047:     decode to FFINT_U_D using decoder 316
                                             //  8047:    }
                                             //  8047:    } // switch Inst[20:16]
                                             //  8047:   }
                                             //  8047:   } // switch Inst[25:21]
                                             //  8047:  }
  32, 7,                                     //  8052:  case 0x20: {
  OPC_CheckPredicate, 30,                    //  8054:   check predicate 30
  OPC_Decode, 128, 15, 191, 2,               //  8056:   decode to LD_B using decoder 319
                                             //  8056:  }
  33, 7,                                     //  8061:  case 0x21: {
  OPC_CheckPredicate, 30,                    //  8063:   check predicate 30
  OPC_Decode, 130, 15, 191, 2,               //  8065:   decode to LD_H using decoder 319
                                             //  8065:  }
  34, 7,                                     //  8070:  case 0x22: {
  OPC_CheckPredicate, 30,                    //  8072:   check predicate 30
  OPC_Decode, 131, 15, 191, 2,               //  8074:   decode to LD_W using decoder 319
                                             //  8074:  }
  35, 7,                                     //  8079:  case 0x23: {
  OPC_CheckPredicate, 30,                    //  8081:   check predicate 30
  OPC_Decode, 129, 15, 191, 2,               //  8083:   decode to LD_D using decoder 319
                                             //  8083:  }
  36, 7,                                     //  8088:  case 0x24: {
  OPC_CheckPredicate, 30,                    //  8090:   check predicate 30
  OPC_Decode, 141, 21, 191, 2,               //  8092:   decode to ST_B using decoder 319
                                             //  8092:  }
  37, 7,                                     //  8097:  case 0x25: {
  OPC_CheckPredicate, 30,                    //  8099:   check predicate 30
  OPC_Decode, 143, 21, 191, 2,               //  8101:   decode to ST_H using decoder 319
                                             //  8101:  }
  38, 7,                                     //  8106:  case 0x26: {
  OPC_CheckPredicate, 30,                    //  8108:   check predicate 30
  OPC_Decode, 144, 21, 191, 2,               //  8110:   decode to ST_W using decoder 319
                                             //  8110:  }
  39, 0,                                     //  8115:  case 0x27: {
  OPC_CheckPredicate, 30,                    //  8117:   check predicate 30
  OPC_Decode, 142, 21, 191, 2,               //  8119:   decode to ST_D using decoder 319
                                             //  8119:  }
                                             //  8119:  } // switch Inst[5:0]
                                             //  8119: }
  31, 135, 15,                               //  8124: case 0x1f: {
  OPC_SwitchField, 0, 6,                     //  8127:  switch Inst[5:0] {
  0, 7,                                      //  8130:  case 0x0: {
  OPC_CheckPredicate, 28,                    //  8132:   check predicate 28
  OPC_Decode, 179, 12, 192, 2,               //  8134:   decode to EXT using decoder 320
                                             //  8134:  }
  4, 7,                                      //  8139:  case 0x4: {
  OPC_CheckPredicate, 28,                    //  8141:   check predicate 28
  OPC_Decode, 167, 14, 193, 2,               //  8143:   decode to INS using decoder 321
                                             //  8143:  }
  8, 11,                                     //  8148:  case 0x8: {
  OPC_CheckPredicate, 42,                    //  8150:   check predicate 42
  OPC_CheckField, 6, 5, 0,                   //  8152:   check Inst[10:6] == 0x0
  OPC_Decode, 204, 13, 194, 2,               //  8156:   decode to FORK using decoder 322
                                             //  8156:  }
  9, 14,                                     //  8161:  case 0x9: {
  OPC_CheckPredicate, 42,                    //  8163:   check predicate 42
  OPC_CheckField, 16, 5, 0,                  //  8165:   check Inst[20:16] == 0x0
  OPC_CheckField, 6, 5, 0,                   //  8169:   check Inst[10:6] == 0x0
  OPC_Decode, 231, 22, 52,                   //  8173:   decode to YIELD using decoder 52
                                             //  8173:  }
  10, 30,                                    //  8177:  case 0xa: {
  OPC_SwitchField, 6, 5,                     //  8179:   switch Inst[10:6] {
  0, 7,                                      //  8182:   case 0x0: {
  OPC_CheckPredicate, 37,                    //  8184:    check predicate 37
  OPC_Decode, 203, 15, 195, 2,               //  8186:    decode to LWX using decoder 323
                                             //  8186:   }
  4, 7,                                      //  8191:   case 0x4: {
  OPC_CheckPredicate, 37,                    //  8193:    check predicate 37
  OPC_Decode, 140, 15, 195, 2,               //  8195:    decode to LHX using decoder 323
                                             //  8195:   }
  6, 0,                                      //  8200:   case 0x6: {
  OPC_CheckPredicate, 37,                    //  8202:    check predicate 37
  OPC_Decode, 227, 14, 195, 2,               //  8204:    decode to LBUX using decoder 323
                                             //  8204:   }
                                             //  8204:   } // switch Inst[10:6]
                                             //  8204:  }
  12, 11,                                    //  8209:  case 0xc: {
  OPC_CheckPredicate, 37,                    //  8211:   check predicate 37
  OPC_CheckField, 6, 10, 0,                  //  8213:   check Inst[15:6] == 0x0
  OPC_Decode, 172, 14, 196, 2,               //  8217:   decode to INSV using decoder 324
                                             //  8217:  }
  16, 218, 1,                                //  8222:  case 0x10: {
  OPC_SwitchField, 6, 5,                     //  8225:   switch Inst[10:6] {
  0, 7,                                      //  8228:   case 0x0: {
  OPC_CheckPredicate, 37,                    //  8230:    check predicate 37
  OPC_Decode, 193, 6, 197, 2,                //  8232:    decode to ADDU_QB using decoder 325
                                             //  8232:   }
  1, 7,                                      //  8237:   case 0x1: {
  OPC_CheckPredicate, 37,                    //  8239:    check predicate 37
  OPC_Decode, 185, 21, 197, 2,               //  8241:    decode to SUBU_QB using decoder 325
                                             //  8241:   }
  4, 7,                                      //  8246:   case 0x4: {
  OPC_CheckPredicate, 37,                    //  8248:    check predicate 37
  OPC_Decode, 197, 6, 197, 2,                //  8250:    decode to ADDU_S_QB using decoder 325
                                             //  8250:   }
  5, 7,                                      //  8255:   case 0x5: {
  OPC_CheckPredicate, 37,                    //  8257:    check predicate 37
  OPC_Decode, 189, 21, 197, 2,               //  8259:    decode to SUBU_S_QB using decoder 325
                                             //  8259:   }
  6, 7,                                      //  8264:   case 0x6: {
  OPC_CheckPredicate, 37,                    //  8266:    check predicate 37
  OPC_Decode, 217, 17, 197, 2,               //  8268:    decode to MULEU_S_PH_QBL using decoder 325
                                             //  8268:   }
  7, 7,                                      //  8273:   case 0x7: {
  OPC_CheckPredicate, 37,                    //  8275:    check predicate 37
  OPC_Decode, 219, 17, 197, 2,               //  8277:    decode to MULEU_S_PH_QBR using decoder 325
                                             //  8277:   }
  8, 7,                                      //  8282:   case 0x8: {
  OPC_CheckPredicate, 69,                    //  8284:    check predicate 69
  OPC_Decode, 191, 6, 197, 2,                //  8286:    decode to ADDU_PH using decoder 325
                                             //  8286:   }
  9, 7,                                      //  8291:   case 0x9: {
  OPC_CheckPredicate, 69,                    //  8293:    check predicate 69
  OPC_Decode, 183, 21, 197, 2,               //  8295:    decode to SUBU_PH using decoder 325
                                             //  8295:   }
  10, 7,                                     //  8300:   case 0xa: {
  OPC_CheckPredicate, 37,                    //  8302:    check predicate 37
  OPC_Decode, 163, 6, 197, 2,                //  8304:    decode to ADDQ_PH using decoder 325
                                             //  8304:   }
  11, 7,                                     //  8309:   case 0xb: {
  OPC_CheckPredicate, 37,                    //  8311:    check predicate 37
  OPC_Decode, 154, 21, 197, 2,               //  8313:    decode to SUBQ_PH using decoder 325
                                             //  8313:   }
  12, 7,                                     //  8318:   case 0xc: {
  OPC_CheckPredicate, 69,                    //  8320:    check predicate 69
  OPC_Decode, 195, 6, 197, 2,                //  8322:    decode to ADDU_S_PH using decoder 325
                                             //  8322:   }
  13, 7,                                     //  8327:   case 0xd: {
  OPC_CheckPredicate, 69,                    //  8329:    check predicate 69
  OPC_Decode, 187, 21, 197, 2,               //  8331:    decode to SUBU_S_PH using decoder 325
                                             //  8331:   }
  14, 7,                                     //  8336:   case 0xe: {
  OPC_CheckPredicate, 37,                    //  8338:    check predicate 37
  OPC_Decode, 165, 6, 197, 2,                //  8340:    decode to ADDQ_S_PH using decoder 325
                                             //  8340:   }
  15, 7,                                     //  8345:   case 0xf: {
  OPC_CheckPredicate, 37,                    //  8347:    check predicate 37
  OPC_Decode, 156, 21, 197, 2,               //  8349:    decode to SUBQ_S_PH using decoder 325
                                             //  8349:   }
  16, 6,                                     //  8354:   case 0x10: {
  OPC_CheckPredicate, 37,                    //  8356:    check predicate 37
  OPC_Decode, 170, 6, 67,                    //  8358:    decode to ADDSC using decoder 67
                                             //  8358:   }
  17, 6,                                     //  8362:   case 0x11: {
  OPC_CheckPredicate, 37,                    //  8364:    check predicate 37
  OPC_Decode, 207, 6, 67,                    //  8366:    decode to ADDWC using decoder 67
                                             //  8366:   }
  18, 6,                                     //  8370:   case 0x12: {
  OPC_CheckPredicate, 37,                    //  8372:    check predicate 37
  OPC_Decode, 215, 16, 67,                   //  8374:    decode to MODSUB using decoder 67
                                             //  8374:   }
  20, 11,                                    //  8378:   case 0x14: {
  OPC_CheckPredicate, 37,                    //  8380:    check predicate 37
  OPC_CheckField, 16, 5, 0,                  //  8382:    check Inst[20:16] == 0x0
  OPC_Decode, 246, 18, 198, 2,               //  8386:    decode to RADDU_W_QB using decoder 326
                                             //  8386:   }
  22, 6,                                     //  8391:   case 0x16: {
  OPC_CheckPredicate, 37,                    //  8393:    check predicate 37
  OPC_Decode, 167, 6, 67,                    //  8395:    decode to ADDQ_S_W using decoder 67
                                             //  8395:   }
  23, 6,                                     //  8399:   case 0x17: {
  OPC_CheckPredicate, 37,                    //  8401:    check predicate 37
  OPC_Decode, 158, 21, 67,                   //  8403:    decode to SUBQ_S_W using decoder 67
                                             //  8403:   }
  28, 7,                                     //  8407:   case 0x1c: {
  OPC_CheckPredicate, 37,                    //  8409:    check predicate 37
  OPC_Decode, 213, 17, 199, 2,               //  8411:    decode to MULEQ_S_W_PHL using decoder 327
                                             //  8411:   }
  29, 7,                                     //  8416:   case 0x1d: {
  OPC_CheckPredicate, 37,                    //  8418:    check predicate 37
  OPC_Decode, 215, 17, 199, 2,               //  8420:    decode to MULEQ_S_W_PHR using decoder 327
                                             //  8420:   }
  30, 7,                                     //  8425:   case 0x1e: {
  OPC_CheckPredicate, 69,                    //  8427:    check predicate 69
  OPC_Decode, 225, 17, 197, 2,               //  8429:    decode to MULQ_S_PH using decoder 325
                                             //  8429:   }
  31, 0,                                     //  8434:   case 0x1f: {
  OPC_CheckPredicate, 37,                    //  8436:    check predicate 37
  OPC_Decode, 221, 17, 197, 2,               //  8438:    decode to MULQ_RS_PH using decoder 325
                                             //  8438:   }
                                             //  8438:   } // switch Inst[10:6]
                                             //  8438:  }
  17, 219, 1,                                //  8443:  case 0x11: {
  OPC_SwitchField, 6, 5,                     //  8446:   switch Inst[10:6] {
  0, 10,                                     //  8449:   case 0x0: {
  OPC_CheckPredicate, 37,                    //  8451:    check predicate 37
  OPC_CheckField, 11, 5, 0,                  //  8453:    check Inst[15:11] == 0x0
  OPC_Decode, 180, 9, 85,                    //  8457:    decode to CMPU_EQ_QB using decoder 85
                                             //  8457:   }
  1, 10,                                     //  8461:   case 0x1: {
  OPC_CheckPredicate, 37,                    //  8463:    check predicate 37
  OPC_CheckField, 11, 5, 0,                  //  8465:    check Inst[15:11] == 0x0
  OPC_Decode, 184, 9, 85,                    //  8469:    decode to CMPU_LT_QB using decoder 85
                                             //  8469:   }
  2, 10,                                     //  8473:   case 0x2: {
  OPC_CheckPredicate, 37,                    //  8475:    check predicate 37
  OPC_CheckField, 11, 5, 0,                  //  8477:    check Inst[15:11] == 0x0
  OPC_Decode, 182, 9, 85,                    //  8481:    decode to CMPU_LE_QB using decoder 85
                                             //  8481:   }
  3, 7,                                      //  8485:   case 0x3: {
  OPC_CheckPredicate, 37,                    //  8487:    check predicate 37
  OPC_Decode, 196, 18, 197, 2,               //  8489:    decode to PICK_QB using decoder 325
                                             //  8489:   }
  4, 7,                                      //  8494:   case 0x4: {
  OPC_CheckPredicate, 37,                    //  8496:    check predicate 37
  OPC_Decode, 174, 9, 199, 2,                //  8498:    decode to CMPGU_EQ_QB using decoder 327
                                             //  8498:   }
  5, 7,                                      //  8503:   case 0x5: {
  OPC_CheckPredicate, 37,                    //  8505:    check predicate 37
  OPC_Decode, 178, 9, 199, 2,                //  8507:    decode to CMPGU_LT_QB using decoder 327
                                             //  8507:   }
  6, 7,                                      //  8512:   case 0x6: {
  OPC_CheckPredicate, 37,                    //  8514:    check predicate 37
  OPC_Decode, 176, 9, 199, 2,                //  8516:    decode to CMPGU_LE_QB using decoder 327
                                             //  8516:   }
  8, 10,                                     //  8521:   case 0x8: {
  OPC_CheckPredicate, 37,                    //  8523:    check predicate 37
  OPC_CheckField, 11, 5, 0,                  //  8525:    check Inst[15:11] == 0x0
  OPC_Decode, 190, 9, 85,                    //  8529:    decode to CMP_EQ_PH using decoder 85
                                             //  8529:   }
  9, 10,                                     //  8533:   case 0x9: {
  OPC_CheckPredicate, 37,                    //  8535:    check predicate 37
  OPC_CheckField, 11, 5, 0,                  //  8537:    check Inst[15:11] == 0x0
  OPC_Decode, 204, 9, 85,                    //  8541:    decode to CMP_LT_PH using decoder 85
                                             //  8541:   }
  10, 10,                                    //  8545:   case 0xa: {
  OPC_CheckPredicate, 37,                    //  8547:    check predicate 37
  OPC_CheckField, 11, 5, 0,                  //  8549:    check Inst[15:11] == 0x0
  OPC_Decode, 198, 9, 85,                    //  8553:    decode to CMP_LE_PH using decoder 85
                                             //  8553:   }
  11, 7,                                     //  8557:   case 0xb: {
  OPC_CheckPredicate, 37,                    //  8559:    check predicate 37
  OPC_Decode, 194, 18, 197, 2,               //  8561:    decode to PICK_PH using decoder 325
                                             //  8561:   }
  12, 7,                                     //  8566:   case 0xc: {
  OPC_CheckPredicate, 37,                    //  8568:    check predicate 37
  OPC_Decode, 225, 18, 197, 2,               //  8570:    decode to PRECRQ_QB_PH using decoder 325
                                             //  8570:   }
  13, 7,                                     //  8575:   case 0xd: {
  OPC_CheckPredicate, 69,                    //  8577:    check predicate 69
  OPC_Decode, 229, 18, 197, 2,               //  8579:    decode to PRECR_QB_PH using decoder 325
                                             //  8579:   }
  14, 7,                                     //  8584:   case 0xe: {
  OPC_CheckPredicate, 37,                    //  8586:    check predicate 37
  OPC_Decode, 177, 18, 197, 2,               //  8588:    decode to PACKRL_PH using decoder 325
                                             //  8588:   }
  15, 7,                                     //  8593:   case 0xf: {
  OPC_CheckPredicate, 37,                    //  8595:    check predicate 37
  OPC_Decode, 221, 18, 197, 2,               //  8597:    decode to PRECRQU_S_QB_PH using decoder 325
                                             //  8597:   }
  20, 7,                                     //  8602:   case 0x14: {
  OPC_CheckPredicate, 37,                    //  8604:    check predicate 37
  OPC_Decode, 223, 18, 200, 2,               //  8606:    decode to PRECRQ_PH_W using decoder 328
                                             //  8606:   }
  21, 7,                                     //  8611:   case 0x15: {
  OPC_CheckPredicate, 37,                    //  8613:    check predicate 37
  OPC_Decode, 227, 18, 200, 2,               //  8615:    decode to PRECRQ_RS_PH_W using decoder 328
                                             //  8615:   }
  24, 7,                                     //  8620:   case 0x18: {
  OPC_CheckPredicate, 69,                    //  8622:    check predicate 69
  OPC_Decode, 168, 9, 199, 2,                //  8624:    decode to CMPGDU_EQ_QB using decoder 327
                                             //  8624:   }
  25, 7,                                     //  8629:   case 0x19: {
  OPC_CheckPredicate, 69,                    //  8631:    check predicate 69
  OPC_Decode, 172, 9, 199, 2,                //  8633:    decode to CMPGDU_LT_QB using decoder 327
                                             //  8633:   }
  26, 7,                                     //  8638:   case 0x1a: {
  OPC_CheckPredicate, 69,                    //  8640:    check predicate 69
  OPC_Decode, 170, 9, 199, 2,                //  8642:    decode to CMPGDU_LE_QB using decoder 327
                                             //  8642:   }
  30, 7,                                     //  8647:   case 0x1e: {
  OPC_CheckPredicate, 69,                    //  8649:    check predicate 69
  OPC_Decode, 231, 18, 201, 2,               //  8651:    decode to PRECR_SRA_PH_W using decoder 329
                                             //  8651:   }
  31, 0,                                     //  8656:   case 0x1f: {
  OPC_CheckPredicate, 69,                    //  8658:    check predicate 69
  OPC_Decode, 233, 18, 201, 2,               //  8660:    decode to PRECR_SRA_R_PH_W using decoder 329
                                             //  8660:   }
                                             //  8660:   } // switch Inst[10:6]
                                             //  8660:  }
  18, 228, 1,                                //  8665:  case 0x12: {
  OPC_SwitchField, 6, 5,                     //  8668:   switch Inst[10:6] {
  1, 11,                                     //  8671:   case 0x1: {
  OPC_CheckPredicate, 69,                    //  8673:    check predicate 69
  OPC_CheckField, 21, 5, 0,                  //  8675:    check Inst[25:21] == 0x0
  OPC_Decode, 142, 6, 202, 2,                //  8679:    decode to ABSQ_S_QB using decoder 330
                                             //  8679:   }
  2, 7,                                      //  8684:   case 0x2: {
  OPC_CheckPredicate, 37,                    //  8686:    check predicate 37
  OPC_Decode, 139, 19, 203, 2,               //  8688:    decode to REPL_QB using decoder 331
                                             //  8688:   }
  3, 11,                                     //  8693:   case 0x3: {
  OPC_CheckPredicate, 37,                    //  8695:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8697:    check Inst[25:21] == 0x0
  OPC_Decode, 135, 19, 204, 2,               //  8701:    decode to REPLV_QB using decoder 332
                                             //  8701:   }
  4, 11,                                     //  8706:   case 0x4: {
  OPC_CheckPredicate, 37,                    //  8708:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8710:    check Inst[25:21] == 0x0
  OPC_Decode, 201, 18, 202, 2,               //  8714:    decode to PRECEQU_PH_QBL using decoder 330
                                             //  8714:   }
  5, 11,                                     //  8719:   case 0x5: {
  OPC_CheckPredicate, 37,                    //  8721:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8723:    check Inst[25:21] == 0x0
  OPC_Decode, 205, 18, 202, 2,               //  8727:    decode to PRECEQU_PH_QBR using decoder 330
                                             //  8727:   }
  6, 11,                                     //  8732:   case 0x6: {
  OPC_CheckPredicate, 37,                    //  8734:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8736:    check Inst[25:21] == 0x0
  OPC_Decode, 202, 18, 202, 2,               //  8740:    decode to PRECEQU_PH_QBLA using decoder 330
                                             //  8740:   }
  7, 11,                                     //  8745:   case 0x7: {
  OPC_CheckPredicate, 37,                    //  8747:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8749:    check Inst[25:21] == 0x0
  OPC_Decode, 206, 18, 202, 2,               //  8753:    decode to PRECEQU_PH_QBRA using decoder 330
                                             //  8753:   }
  9, 11,                                     //  8758:   case 0x9: {
  OPC_CheckPredicate, 37,                    //  8760:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8762:    check Inst[25:21] == 0x0
  OPC_Decode, 140, 6, 202, 2,                //  8766:    decode to ABSQ_S_PH using decoder 330
                                             //  8766:   }
  10, 6,                                     //  8771:   case 0xa: {
  OPC_CheckPredicate, 37,                    //  8773:    check predicate 37
  OPC_Decode, 137, 19, 103,                  //  8775:    decode to REPL_PH using decoder 103
                                             //  8775:   }
  11, 11,                                    //  8779:   case 0xb: {
  OPC_CheckPredicate, 37,                    //  8781:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8783:    check Inst[25:21] == 0x0
  OPC_Decode, 133, 19, 204, 2,               //  8787:    decode to REPLV_PH using decoder 332
                                             //  8787:   }
  12, 11,                                    //  8792:   case 0xc: {
  OPC_CheckPredicate, 37,                    //  8794:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8796:    check Inst[25:21] == 0x0
  OPC_Decode, 209, 18, 205, 2,               //  8800:    decode to PRECEQ_W_PHL using decoder 333
                                             //  8800:   }
  13, 11,                                    //  8805:   case 0xd: {
  OPC_CheckPredicate, 37,                    //  8807:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8809:    check Inst[25:21] == 0x0
  OPC_Decode, 211, 18, 205, 2,               //  8813:    decode to PRECEQ_W_PHR using decoder 333
                                             //  8813:   }
  17, 11,                                    //  8818:   case 0x11: {
  OPC_CheckPredicate, 37,                    //  8820:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8822:    check Inst[25:21] == 0x0
  OPC_Decode, 144, 6, 206, 2,                //  8826:    decode to ABSQ_S_W using decoder 334
                                             //  8826:   }
  27, 11,                                    //  8831:   case 0x1b: {
  OPC_CheckPredicate, 37,                    //  8833:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8835:    check Inst[25:21] == 0x0
  OPC_Decode, 245, 7, 206, 2,                //  8839:    decode to BITREV using decoder 334
                                             //  8839:   }
  28, 11,                                    //  8844:   case 0x1c: {
  OPC_CheckPredicate, 37,                    //  8846:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8848:    check Inst[25:21] == 0x0
  OPC_Decode, 213, 18, 202, 2,               //  8852:    decode to PRECEU_PH_QBL using decoder 330
                                             //  8852:   }
  29, 11,                                    //  8857:   case 0x1d: {
  OPC_CheckPredicate, 37,                    //  8859:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8861:    check Inst[25:21] == 0x0
  OPC_Decode, 217, 18, 202, 2,               //  8865:    decode to PRECEU_PH_QBR using decoder 330
                                             //  8865:   }
  30, 11,                                    //  8870:   case 0x1e: {
  OPC_CheckPredicate, 37,                    //  8872:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8874:    check Inst[25:21] == 0x0
  OPC_Decode, 214, 18, 202, 2,               //  8878:    decode to PRECEU_PH_QBLA using decoder 330
                                             //  8878:   }
  31, 0,                                     //  8883:   case 0x1f: {
  OPC_CheckPredicate, 37,                    //  8885:    check predicate 37
  OPC_CheckField, 21, 5, 0,                  //  8887:    check Inst[25:21] == 0x0
  OPC_Decode, 218, 18, 202, 2,               //  8891:    decode to PRECEU_PH_QBRA using decoder 330
                                             //  8891:   }
                                             //  8891:   } // switch Inst[10:6]
                                             //  8891:  }
  19, 199, 1,                                //  8896:  case 0x13: {
  OPC_SwitchField, 6, 5,                     //  8899:   switch Inst[10:6] {
  0, 7,                                      //  8902:   case 0x0: {
  OPC_CheckPredicate, 37,                    //  8904:    check predicate 37
  OPC_Decode, 139, 20, 207, 2,               //  8906:    decode to SHLL_QB using decoder 335
                                             //  8906:   }
  1, 7,                                      //  8911:   case 0x1: {
  OPC_CheckPredicate, 37,                    //  8913:    check predicate 37
  OPC_Decode, 171, 20, 207, 2,               //  8915:    decode to SHRL_QB using decoder 335
                                             //  8915:   }
  2, 7,                                      //  8920:   case 0x2: {
  OPC_CheckPredicate, 37,                    //  8922:    check predicate 37
  OPC_Decode, 131, 20, 208, 2,               //  8924:    decode to SHLLV_QB using decoder 336
                                             //  8924:   }
  3, 7,                                      //  8929:   case 0x3: {
  OPC_CheckPredicate, 37,                    //  8931:    check predicate 37
  OPC_Decode, 167, 20, 208, 2,               //  8933:    decode to SHRLV_QB using decoder 336
                                             //  8933:   }
  4, 7,                                      //  8938:   case 0x4: {
  OPC_CheckPredicate, 69,                    //  8940:    check predicate 69
  OPC_Decode, 157, 20, 207, 2,               //  8942:    decode to SHRA_QB using decoder 335
                                             //  8942:   }
  5, 7,                                      //  8947:   case 0x5: {
  OPC_CheckPredicate, 69,                    //  8949:    check predicate 69
  OPC_Decode, 161, 20, 207, 2,               //  8951:    decode to SHRA_R_QB using decoder 335
                                             //  8951:   }
  6, 7,                                      //  8956:   case 0x6: {
  OPC_CheckPredicate, 69,                    //  8958:    check predicate 69
  OPC_Decode, 147, 20, 208, 2,               //  8960:    decode to SHRAV_QB using decoder 336
                                             //  8960:   }
  7, 7,                                      //  8965:   case 0x7: {
  OPC_CheckPredicate, 69,                    //  8967:    check predicate 69
  OPC_Decode, 151, 20, 208, 2,               //  8969:    decode to SHRAV_R_QB using decoder 336
                                             //  8969:   }
  8, 7,                                      //  8974:   case 0x8: {
  OPC_CheckPredicate, 37,                    //  8976:    check predicate 37
  OPC_Decode, 137, 20, 207, 2,               //  8978:    decode to SHLL_PH using decoder 335
                                             //  8978:   }
  9, 7,                                      //  8983:   case 0x9: {
  OPC_CheckPredicate, 37,                    //  8985:    check predicate 37
  OPC_Decode, 155, 20, 207, 2,               //  8987:    decode to SHRA_PH using decoder 335
                                             //  8987:   }
  10, 7,                                     //  8992:   case 0xa: {
  OPC_CheckPredicate, 37,                    //  8994:    check predicate 37
  OPC_Decode, 129, 20, 208, 2,               //  8996:    decode to SHLLV_PH using decoder 336
                                             //  8996:   }
  11, 7,                                     //  9001:   case 0xb: {
  OPC_CheckPredicate, 37,                    //  9003:    check predicate 37
  OPC_Decode, 145, 20, 208, 2,               //  9005:    decode to SHRAV_PH using decoder 336
                                             //  9005:   }
  12, 7,                                     //  9010:   case 0xc: {
  OPC_CheckPredicate, 37,                    //  9012:    check predicate 37
  OPC_Decode, 141, 20, 207, 2,               //  9014:    decode to SHLL_S_PH using decoder 335
                                             //  9014:   }
  13, 7,                                     //  9019:   case 0xd: {
  OPC_CheckPredicate, 37,                    //  9021:    check predicate 37
  OPC_Decode, 159, 20, 207, 2,               //  9023:    decode to SHRA_R_PH using decoder 335
                                             //  9023:   }
  14, 7,                                     //  9028:   case 0xe: {
  OPC_CheckPredicate, 37,                    //  9030:    check predicate 37
  OPC_Decode, 133, 20, 208, 2,               //  9032:    decode to SHLLV_S_PH using decoder 336
                                             //  9032:   }
  15, 7,                                     //  9037:   case 0xf: {
  OPC_CheckPredicate, 37,                    //  9039:    check predicate 37
  OPC_Decode, 149, 20, 208, 2,               //  9041:    decode to SHRAV_R_PH using decoder 336
                                             //  9041:   }
  20, 7,                                     //  9046:   case 0x14: {
  OPC_CheckPredicate, 37,                    //  9048:    check predicate 37
  OPC_Decode, 143, 20, 209, 2,               //  9050:    decode to SHLL_S_W using decoder 337
                                             //  9050:   }
  21, 7,                                     //  9055:   case 0x15: {
  OPC_CheckPredicate, 37,                    //  9057:    check predicate 37
  OPC_Decode, 163, 20, 209, 2,               //  9059:    decode to SHRA_R_W using decoder 337
                                             //  9059:   }
  22, 6,                                     //  9064:   case 0x16: {
  OPC_CheckPredicate, 37,                    //  9066:    check predicate 37
  OPC_Decode, 135, 20, 61,                   //  9068:    decode to SHLLV_S_W using decoder 61
                                             //  9068:   }
  23, 6,                                     //  9072:   case 0x17: {
  OPC_CheckPredicate, 37,                    //  9074:    check predicate 37
  OPC_Decode, 153, 20, 61,                   //  9076:    decode to SHRAV_R_W using decoder 61
                                             //  9076:   }
  25, 7,                                     //  9080:   case 0x19: {
  OPC_CheckPredicate, 69,                    //  9082:    check predicate 69
  OPC_Decode, 169, 20, 207, 2,               //  9084:    decode to SHRL_PH using decoder 335
                                             //  9084:   }
  27, 0,                                     //  9089:   case 0x1b: {
  OPC_CheckPredicate, 69,                    //  9091:    check predicate 69
  OPC_Decode, 165, 20, 208, 2,               //  9093:    decode to SHRLV_PH using decoder 336
                                             //  9093:   }
                                             //  9093:   } // switch Inst[10:6]
                                             //  9093:  }
  24, 141, 1,                                //  9098:  case 0x18: {
  OPC_SwitchField, 6, 5,                     //  9101:   switch Inst[10:6] {
  0, 7,                                      //  9104:   case 0x0: {
  OPC_CheckPredicate, 69,                    //  9106:    check predicate 69
  OPC_Decode, 186, 6, 197, 2,                //  9108:    decode to ADDUH_QB using decoder 325
                                             //  9108:   }
  1, 7,                                      //  9113:   case 0x1: {
  OPC_CheckPredicate, 69,                    //  9115:    check predicate 69
  OPC_Decode, 178, 21, 197, 2,               //  9117:    decode to SUBUH_QB using decoder 325
                                             //  9117:   }
  2, 7,                                      //  9122:   case 0x2: {
  OPC_CheckPredicate, 69,                    //  9124:    check predicate 69
  OPC_Decode, 188, 6, 197, 2,                //  9126:    decode to ADDUH_R_QB using decoder 325
                                             //  9126:   }
  3, 7,                                      //  9131:   case 0x3: {
  OPC_CheckPredicate, 69,                    //  9133:    check predicate 69
  OPC_Decode, 180, 21, 197, 2,               //  9135:    decode to SUBUH_R_QB using decoder 325
                                             //  9135:   }
  8, 7,                                      //  9140:   case 0x8: {
  OPC_CheckPredicate, 69,                    //  9142:    check predicate 69
  OPC_Decode, 155, 6, 197, 2,                //  9144:    decode to ADDQH_PH using decoder 325
                                             //  9144:   }
  9, 7,                                      //  9149:   case 0x9: {
  OPC_CheckPredicate, 69,                    //  9151:    check predicate 69
  OPC_Decode, 146, 21, 197, 2,               //  9153:    decode to SUBQH_PH using decoder 325
                                             //  9153:   }
  10, 7,                                     //  9158:   case 0xa: {
  OPC_CheckPredicate, 69,                    //  9160:    check predicate 69
  OPC_Decode, 157, 6, 197, 2,                //  9162:    decode to ADDQH_R_PH using decoder 325
                                             //  9162:   }
  11, 7,                                     //  9167:   case 0xb: {
  OPC_CheckPredicate, 69,                    //  9169:    check predicate 69
  OPC_Decode, 148, 21, 197, 2,               //  9171:    decode to SUBQH_R_PH using decoder 325
                                             //  9171:   }
  12, 7,                                     //  9176:   case 0xc: {
  OPC_CheckPredicate, 69,                    //  9178:    check predicate 69
  OPC_Decode, 252, 17, 197, 2,               //  9180:    decode to MUL_PH using decoder 325
                                             //  9180:   }
  14, 7,                                     //  9185:   case 0xe: {
  OPC_CheckPredicate, 69,                    //  9187:    check predicate 69
  OPC_Decode, 129, 18, 197, 2,               //  9189:    decode to MUL_S_PH using decoder 325
                                             //  9189:   }
  16, 6,                                     //  9194:   case 0x10: {
  OPC_CheckPredicate, 69,                    //  9196:    check predicate 69
  OPC_Decode, 161, 6, 67,                    //  9198:    decode to ADDQH_W using decoder 67
                                             //  9198:   }
  17, 6,                                     //  9202:   case 0x11: {
  OPC_CheckPredicate, 69,                    //  9204:    check predicate 69
  OPC_Decode, 152, 21, 67,                   //  9206:    decode to SUBQH_W using decoder 67
                                             //  9206:   }
  18, 6,                                     //  9210:   case 0x12: {
  OPC_CheckPredicate, 69,                    //  9212:    check predicate 69
  OPC_Decode, 159, 6, 67,                    //  9214:    decode to ADDQH_R_W using decoder 67
                                             //  9214:   }
  19, 6,                                     //  9218:   case 0x13: {
  OPC_CheckPredicate, 69,                    //  9220:    check predicate 69
  OPC_Decode, 150, 21, 67,                   //  9222:    decode to SUBQH_R_W using decoder 67
                                             //  9222:   }
  22, 6,                                     //  9226:   case 0x16: {
  OPC_CheckPredicate, 69,                    //  9228:    check predicate 69
  OPC_Decode, 227, 17, 67,                   //  9230:    decode to MULQ_S_W using decoder 67
                                             //  9230:   }
  23, 0,                                     //  9234:   case 0x17: {
  OPC_CheckPredicate, 69,                    //  9236:    check predicate 69
  OPC_Decode, 223, 17, 67,                   //  9238:    decode to MULQ_RS_W using decoder 67
                                             //  9238:   }
                                             //  9238:   } // switch Inst[10:6]
                                             //  9238:  }
  25, 11,                                    //  9242:  case 0x19: {
  OPC_CheckPredicate, 70,                    //  9244:   check predicate 70
  OPC_CheckField, 6, 1, 0,                   //  9246:   check Inst[6] == 0x0
  OPC_Decode, 186, 15, 210, 2,               //  9250:   decode to LWLE using decoder 338
                                             //  9250:  }
  26, 11,                                    //  9255:  case 0x1a: {
  OPC_CheckPredicate, 70,                    //  9257:   check predicate 70
  OPC_CheckField, 6, 1, 0,                   //  9259:   check Inst[6] == 0x0
  OPC_Decode, 197, 15, 210, 2,               //  9263:   decode to LWRE using decoder 338
                                             //  9263:  }
  27, 11,                                    //  9268:  case 0x1b: {
  OPC_CheckPredicate, 44,                    //  9270:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9272:   check Inst[6] == 0x0
  OPC_Decode, 220, 8, 211, 2,                //  9276:   decode to CACHEE using decoder 339
                                             //  9276:  }
  28, 11,                                    //  9281:  case 0x1c: {
  OPC_CheckPredicate, 44,                    //  9283:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9285:   check Inst[6] == 0x0
  OPC_Decode, 182, 19, 210, 2,               //  9289:   decode to SBE using decoder 338
                                             //  9289:  }
  29, 11,                                    //  9294:  case 0x1d: {
  OPC_CheckPredicate, 44,                    //  9296:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9298:   check Inst[6] == 0x0
  OPC_Decode, 248, 19, 210, 2,               //  9302:   decode to SHE using decoder 338
                                             //  9302:  }
  30, 11,                                    //  9307:  case 0x1e: {
  OPC_CheckPredicate, 44,                    //  9309:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9311:   check Inst[6] == 0x0
  OPC_Decode, 191, 19, 210, 2,               //  9315:   decode to SCE using decoder 338
                                             //  9315:  }
  31, 11,                                    //  9320:  case 0x1f: {
  OPC_CheckPredicate, 44,                    //  9322:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9324:   check Inst[6] == 0x0
  OPC_Decode, 218, 21, 210, 2,               //  9328:   decode to SWE using decoder 338
                                             //  9328:  }
  32, 42,                                    //  9333:  case 0x20: {
  OPC_SwitchField, 6, 5,                     //  9335:   switch Inst[10:6] {
  2, 11,                                     //  9338:   case 0x2: {
  OPC_CheckPredicate, 28,                    //  9340:    check predicate 28
  OPC_CheckField, 21, 5, 0,                  //  9342:    check Inst[25:21] == 0x0
  OPC_Decode, 215, 22, 206, 2,               //  9346:    decode to WSBH using decoder 334
                                             //  9346:   }
  16, 11,                                    //  9351:   case 0x10: {
  OPC_CheckPredicate, 28,                    //  9353:    check predicate 28
  OPC_CheckField, 21, 5, 0,                  //  9355:    check Inst[25:21] == 0x0
  OPC_Decode, 218, 19, 206, 2,               //  9359:    decode to SEB using decoder 334
                                             //  9359:   }
  24, 0,                                     //  9364:   case 0x18: {
  OPC_CheckPredicate, 28,                    //  9366:    check predicate 28
  OPC_CheckField, 21, 5, 0,                  //  9368:    check Inst[25:21] == 0x0
  OPC_Decode, 221, 19, 206, 2,               //  9372:    decode to SEH using decoder 334
                                             //  9372:   }
                                             //  9372:   } // switch Inst[10:6]
                                             //  9372:  }
  33, 11,                                    //  9377:  case 0x21: {
  OPC_CheckPredicate, 70,                    //  9379:   check predicate 70
  OPC_CheckField, 6, 1, 0,                   //  9381:   check Inst[6] == 0x0
  OPC_Decode, 222, 21, 210, 2,               //  9385:   decode to SWLE using decoder 338
                                             //  9385:  }
  34, 11,                                    //  9390:  case 0x22: {
  OPC_CheckPredicate, 70,                    //  9392:   check predicate 70
  OPC_CheckField, 6, 1, 0,                   //  9394:   check Inst[6] == 0x0
  OPC_Decode, 231, 21, 210, 2,               //  9398:   decode to SWRE using decoder 338
                                             //  9398:  }
  35, 11,                                    //  9403:  case 0x23: {
  OPC_CheckPredicate, 44,                    //  9405:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9407:   check Inst[6] == 0x0
  OPC_Decode, 236, 18, 211, 2,               //  9411:   decode to PREFE using decoder 339
                                             //  9411:  }
  40, 11,                                    //  9416:  case 0x28: {
  OPC_CheckPredicate, 44,                    //  9418:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9420:   check Inst[6] == 0x0
  OPC_Decode, 234, 14, 210, 2,               //  9424:   decode to LBuE using decoder 338
                                             //  9424:  }
  41, 11,                                    //  9429:  case 0x29: {
  OPC_CheckPredicate, 44,                    //  9431:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9433:   check Inst[6] == 0x0
  OPC_Decode, 145, 15, 210, 2,               //  9437:   decode to LHuE using decoder 338
                                             //  9437:  }
  44, 11,                                    //  9442:  case 0x2c: {
  OPC_CheckPredicate, 44,                    //  9444:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9446:   check Inst[6] == 0x0
  OPC_Decode, 224, 14, 210, 2,               //  9450:   decode to LBE using decoder 338
                                             //  9450:  }
  45, 11,                                    //  9455:  case 0x2d: {
  OPC_CheckPredicate, 44,                    //  9457:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9459:   check Inst[6] == 0x0
  OPC_Decode, 137, 15, 210, 2,               //  9463:   decode to LHE using decoder 338
                                             //  9463:  }
  46, 11,                                    //  9468:  case 0x2e: {
  OPC_CheckPredicate, 44,                    //  9470:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9472:   check Inst[6] == 0x0
  OPC_Decode, 155, 15, 210, 2,               //  9476:   decode to LLE using decoder 338
                                             //  9476:  }
  47, 11,                                    //  9481:  case 0x2f: {
  OPC_CheckPredicate, 44,                    //  9483:   check predicate 44
  OPC_CheckField, 6, 1, 0,                   //  9485:   check Inst[6] == 0x0
  OPC_Decode, 181, 15, 210, 2,               //  9489:   decode to LWE using decoder 338
                                             //  9489:  }
  48, 161, 2,                                //  9494:  case 0x30: {
  OPC_SwitchField, 6, 5,                     //  9497:   switch Inst[10:6] {
  0, 11,                                     //  9500:   case 0x0: {
  OPC_CheckPredicate, 69,                    //  9502:    check predicate 69
  OPC_CheckField, 13, 3, 0,                  //  9504:    check Inst[15:13] == 0x0
  OPC_Decode, 243, 11, 212, 2,               //  9508:    decode to DPA_W_PH using decoder 340
                                             //  9508:   }
  1, 11,                                     //  9513:   case 0x1: {
  OPC_CheckPredicate, 69,                    //  9515:    check predicate 69
  OPC_CheckField, 13, 3, 0,                  //  9517:    check Inst[15:13] == 0x0
  OPC_Decode, 138, 12, 212, 2,               //  9521:    decode to DPS_W_PH using decoder 340
                                             //  9521:   }
  2, 11,                                     //  9526:   case 0x2: {
  OPC_CheckPredicate, 69,                    //  9528:    check predicate 69
  OPC_CheckField, 13, 3, 0,                  //  9530:    check Inst[15:13] == 0x0
  OPC_Decode, 234, 17, 212, 2,               //  9534:    decode to MULSA_W_PH using decoder 340
                                             //  9534:   }
  3, 11,                                     //  9539:   case 0x3: {
  OPC_CheckPredicate, 37,                    //  9541:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9543:    check Inst[15:13] == 0x0
  OPC_Decode, 237, 11, 212, 2,               //  9547:    decode to DPAU_H_QBL using decoder 340
                                             //  9547:   }
  4, 11,                                     //  9552:   case 0x4: {
  OPC_CheckPredicate, 37,                    //  9554:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9556:    check Inst[15:13] == 0x0
  OPC_Decode, 235, 11, 212, 2,               //  9560:    decode to DPAQ_S_W_PH using decoder 340
                                             //  9560:   }
  5, 11,                                     //  9565:   case 0x5: {
  OPC_CheckPredicate, 37,                    //  9567:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9569:    check Inst[15:13] == 0x0
  OPC_Decode, 252, 11, 212, 2,               //  9573:    decode to DPSQ_S_W_PH using decoder 340
                                             //  9573:   }
  6, 11,                                     //  9578:   case 0x6: {
  OPC_CheckPredicate, 37,                    //  9580:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9582:    check Inst[15:13] == 0x0
  OPC_Decode, 232, 17, 212, 2,               //  9586:    decode to MULSAQ_S_W_PH using decoder 340
                                             //  9586:   }
  7, 11,                                     //  9591:   case 0x7: {
  OPC_CheckPredicate, 37,                    //  9593:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9595:    check Inst[15:13] == 0x0
  OPC_Decode, 239, 11, 212, 2,               //  9599:    decode to DPAU_H_QBR using decoder 340
                                             //  9599:   }
  8, 11,                                     //  9604:   case 0x8: {
  OPC_CheckPredicate, 69,                    //  9606:    check predicate 69
  OPC_CheckField, 13, 3, 0,                  //  9608:    check Inst[15:13] == 0x0
  OPC_Decode, 241, 11, 212, 2,               //  9612:    decode to DPAX_W_PH using decoder 340
                                             //  9612:   }
  9, 11,                                     //  9617:   case 0x9: {
  OPC_CheckPredicate, 69,                    //  9619:    check predicate 69
  OPC_CheckField, 13, 3, 0,                  //  9621:    check Inst[15:13] == 0x0
  OPC_Decode, 136, 12, 212, 2,               //  9625:    decode to DPSX_W_PH using decoder 340
                                             //  9625:   }
  11, 11,                                    //  9630:   case 0xb: {
  OPC_CheckPredicate, 37,                    //  9632:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9634:    check Inst[15:13] == 0x0
  OPC_Decode, 132, 12, 212, 2,               //  9638:    decode to DPSU_H_QBL using decoder 340
                                             //  9638:   }
  12, 11,                                    //  9643:   case 0xc: {
  OPC_CheckPredicate, 37,                    //  9645:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9647:    check Inst[15:13] == 0x0
  OPC_Decode, 233, 11, 212, 2,               //  9651:    decode to DPAQ_SA_L_W using decoder 340
                                             //  9651:   }
  13, 11,                                    //  9656:   case 0xd: {
  OPC_CheckPredicate, 37,                    //  9658:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9660:    check Inst[15:13] == 0x0
  OPC_Decode, 250, 11, 212, 2,               //  9664:    decode to DPSQ_SA_L_W using decoder 340
                                             //  9664:   }
  15, 11,                                    //  9669:   case 0xf: {
  OPC_CheckPredicate, 37,                    //  9671:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9673:    check Inst[15:13] == 0x0
  OPC_Decode, 134, 12, 212, 2,               //  9677:    decode to DPSU_H_QBR using decoder 340
                                             //  9677:   }
  16, 11,                                    //  9682:   case 0x10: {
  OPC_CheckPredicate, 37,                    //  9684:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9686:    check Inst[15:13] == 0x0
  OPC_Decode, 247, 15, 212, 2,               //  9690:    decode to MAQ_SA_W_PHL using decoder 340
                                             //  9690:   }
  18, 11,                                    //  9695:   case 0x12: {
  OPC_CheckPredicate, 37,                    //  9697:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9699:    check Inst[15:13] == 0x0
  OPC_Decode, 249, 15, 212, 2,               //  9703:    decode to MAQ_SA_W_PHR using decoder 340
                                             //  9703:   }
  20, 11,                                    //  9708:   case 0x14: {
  OPC_CheckPredicate, 37,                    //  9710:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9712:    check Inst[15:13] == 0x0
  OPC_Decode, 251, 15, 212, 2,               //  9716:    decode to MAQ_S_W_PHL using decoder 340
                                             //  9716:   }
  22, 11,                                    //  9721:   case 0x16: {
  OPC_CheckPredicate, 37,                    //  9723:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9725:    check Inst[15:13] == 0x0
  OPC_Decode, 253, 15, 212, 2,               //  9729:    decode to MAQ_S_W_PHR using decoder 340
                                             //  9729:   }
  24, 11,                                    //  9734:   case 0x18: {
  OPC_CheckPredicate, 69,                    //  9736:    check predicate 69
  OPC_CheckField, 13, 3, 0,                  //  9738:    check Inst[15:13] == 0x0
  OPC_Decode, 231, 11, 212, 2,               //  9742:    decode to DPAQX_S_W_PH using decoder 340
                                             //  9742:   }
  25, 11,                                    //  9747:   case 0x19: {
  OPC_CheckPredicate, 69,                    //  9749:    check predicate 69
  OPC_CheckField, 13, 3, 0,                  //  9751:    check Inst[15:13] == 0x0
  OPC_Decode, 248, 11, 212, 2,               //  9755:    decode to DPSQX_S_W_PH using decoder 340
                                             //  9755:   }
  26, 11,                                    //  9760:   case 0x1a: {
  OPC_CheckPredicate, 69,                    //  9762:    check predicate 69
  OPC_CheckField, 13, 3, 0,                  //  9764:    check Inst[15:13] == 0x0
  OPC_Decode, 229, 11, 212, 2,               //  9768:    decode to DPAQX_SA_W_PH using decoder 340
                                             //  9768:   }
  27, 0,                                     //  9773:   case 0x1b: {
  OPC_CheckPredicate, 69,                    //  9775:    check predicate 69
  OPC_CheckField, 13, 3, 0,                  //  9777:    check Inst[15:13] == 0x0
  OPC_Decode, 246, 11, 212, 2,               //  9781:    decode to DPSQX_SA_W_PH using decoder 340
                                             //  9781:   }
                                             //  9781:   } // switch Inst[10:6]
                                             //  9781:  }
  49, 30,                                    //  9786:  case 0x31: {
  OPC_SwitchField, 6, 5,                     //  9788:   switch Inst[10:6] {
  0, 7,                                      //  9791:   case 0x0: {
  OPC_CheckPredicate, 69,                    //  9793:    check predicate 69
  OPC_Decode, 239, 6, 213, 2,                //  9795:    decode to APPEND using decoder 341
                                             //  9795:   }
  1, 7,                                      //  9800:   case 0x1: {
  OPC_CheckPredicate, 69,                    //  9802:    check predicate 69
  OPC_Decode, 242, 18, 213, 2,               //  9804:    decode to PREPEND using decoder 341
                                             //  9804:   }
  16, 0,                                     //  9809:   case 0x10: {
  OPC_CheckPredicate, 69,                    //  9811:    check predicate 69
  OPC_Decode, 155, 7, 213, 2,                //  9813:    decode to BALIGN using decoder 341
                                             //  9813:   }
                                             //  9813:   } // switch Inst[10:6]
                                             //  9813:  }
  56, 216, 1,                                //  9818:  case 0x38: {
  OPC_SwitchField, 6, 5,                     //  9821:   switch Inst[10:6] {
  0, 11,                                     //  9824:   case 0x0: {
  OPC_CheckPredicate, 37,                    //  9826:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9828:    check Inst[15:13] == 0x0
  OPC_Decode, 202, 12, 214, 2,               //  9832:    decode to EXTR_W using decoder 342
                                             //  9832:   }
  1, 11,                                     //  9837:   case 0x1: {
  OPC_CheckPredicate, 37,                    //  9839:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9841:    check Inst[15:13] == 0x0
  OPC_Decode, 194, 12, 215, 2,               //  9845:    decode to EXTRV_W using decoder 343
                                             //  9845:   }
  2, 11,                                     //  9850:   case 0x2: {
  OPC_CheckPredicate, 37,                    //  9852:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9854:    check Inst[15:13] == 0x0
  OPC_Decode, 180, 12, 214, 2,               //  9858:    decode to EXTP using decoder 342
                                             //  9858:   }
  3, 11,                                     //  9863:   case 0x3: {
  OPC_CheckPredicate, 37,                    //  9865:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9867:    check Inst[15:13] == 0x0
  OPC_Decode, 185, 12, 215, 2,               //  9871:    decode to EXTPV using decoder 343
                                             //  9871:   }
  4, 11,                                     //  9876:   case 0x4: {
  OPC_CheckPredicate, 37,                    //  9878:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9880:    check Inst[15:13] == 0x0
  OPC_Decode, 198, 12, 214, 2,               //  9884:    decode to EXTR_R_W using decoder 342
                                             //  9884:   }
  5, 11,                                     //  9889:   case 0x5: {
  OPC_CheckPredicate, 37,                    //  9891:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9893:    check Inst[15:13] == 0x0
  OPC_Decode, 190, 12, 215, 2,               //  9897:    decode to EXTRV_R_W using decoder 343
                                             //  9897:   }
  6, 11,                                     //  9902:   case 0x6: {
  OPC_CheckPredicate, 37,                    //  9904:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9906:    check Inst[15:13] == 0x0
  OPC_Decode, 196, 12, 214, 2,               //  9910:    decode to EXTR_RS_W using decoder 342
                                             //  9910:   }
  7, 11,                                     //  9915:   case 0x7: {
  OPC_CheckPredicate, 37,                    //  9917:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9919:    check Inst[15:13] == 0x0
  OPC_Decode, 188, 12, 215, 2,               //  9923:    decode to EXTRV_RS_W using decoder 343
                                             //  9923:   }
  10, 11,                                    //  9928:   case 0xa: {
  OPC_CheckPredicate, 37,                    //  9930:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9932:    check Inst[15:13] == 0x0
  OPC_Decode, 181, 12, 214, 2,               //  9936:    decode to EXTPDP using decoder 342
                                             //  9936:   }
  11, 11,                                    //  9941:   case 0xb: {
  OPC_CheckPredicate, 37,                    //  9943:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9945:    check Inst[15:13] == 0x0
  OPC_Decode, 182, 12, 215, 2,               //  9949:    decode to EXTPDPV using decoder 343
                                             //  9949:   }
  14, 11,                                    //  9954:   case 0xe: {
  OPC_CheckPredicate, 37,                    //  9956:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9958:    check Inst[15:13] == 0x0
  OPC_Decode, 200, 12, 214, 2,               //  9962:    decode to EXTR_S_H using decoder 342
                                             //  9962:   }
  15, 11,                                    //  9967:   case 0xf: {
  OPC_CheckPredicate, 37,                    //  9969:    check predicate 37
  OPC_CheckField, 13, 3, 0,                  //  9971:    check Inst[15:13] == 0x0
  OPC_Decode, 192, 12, 215, 2,               //  9975:    decode to EXTRV_S_H using decoder 343
                                             //  9975:   }
  18, 7,                                     //  9980:   case 0x12: {
  OPC_CheckPredicate, 37,                    //  9982:    check predicate 37
  OPC_Decode, 248, 18, 216, 2,               //  9984:    decode to RDDSP using decoder 344
                                             //  9984:   }
  19, 7,                                     //  9989:   case 0x13: {
  OPC_CheckPredicate, 40,                    //  9991:    check predicate 40
  OPC_Decode, 212, 22, 217, 2,               //  9993:    decode to WRDSP using decoder 345
                                             //  9993:   }
  26, 11,                                    //  9998:   case 0x1a: {
  OPC_CheckPredicate, 37,                    // 10000:    check predicate 37
  OPC_CheckField, 13, 7, 0,                  // 10002:    check Inst[19:13] == 0x0
  OPC_Decode, 253, 19, 218, 2,               // 10006:    decode to SHILO using decoder 346
                                             // 10006:   }
  27, 11,                                    // 10011:   case 0x1b: {
  OPC_CheckPredicate, 37,                    // 10013:    check predicate 37
  OPC_CheckField, 13, 8, 0,                  // 10015:    check Inst[20:13] == 0x0
  OPC_Decode, 254, 19, 219, 2,               // 10019:    decode to SHILOV using decoder 347
                                             // 10019:   }
  31, 0,                                     // 10024:   case 0x1f: {
  OPC_CheckPredicate, 37,                    // 10026:    check predicate 37
  OPC_CheckField, 13, 8, 0,                  // 10028:    check Inst[20:13] == 0x0
  OPC_Decode, 194, 17, 219, 2,               // 10032:    decode to MTHLIP using decoder 347
                                             // 10032:   }
                                             // 10032:   } // switch Inst[10:6]
                                             // 10032:  }
  59, 0,                                     // 10037:  case 0x3b: {
  OPC_CheckPredicate, 27,                    // 10039:   check predicate 27
  OPC_CheckField, 21, 5, 0,                  // 10041:   check Inst[25:21] == 0x0
  OPC_CheckField, 9, 2, 0,                   // 10045:   check Inst[10:9] == 0x0
  OPC_Decode, 250, 18, 220, 2,               // 10049:   decode to RDHWR using decoder 348
                                             // 10049:  }
                                             // 10049:  } // switch Inst[5:0]
                                             // 10049: }
  32, 7,                                     // 10054: case 0x20: {
  OPC_CheckPredicate, 27,                    // 10056:  check predicate 27
  OPC_Decode, 222, 14, 148, 1,               // 10058:  decode to LB using decoder 148
                                             // 10058: }
  33, 7,                                     // 10063: case 0x21: {
  OPC_CheckPredicate, 27,                    // 10065:  check predicate 27
  OPC_Decode, 135, 15, 148, 1,               // 10067:  decode to LH using decoder 148
                                             // 10067: }
  34, 7,                                     // 10072: case 0x22: {
  OPC_CheckPredicate, 31,                    // 10074:  check predicate 31
  OPC_Decode, 184, 15, 148, 1,               // 10076:  decode to LWL using decoder 148
                                             // 10076: }
  35, 7,                                     // 10081: case 0x23: {
  OPC_CheckPredicate, 27,                    // 10083:  check predicate 27
  OPC_Decode, 170, 15, 148, 1,               // 10085:  decode to LW using decoder 148
                                             // 10085: }
  36, 7,                                     // 10090: case 0x24: {
  OPC_CheckPredicate, 27,                    // 10092:  check predicate 27
  OPC_Decode, 232, 14, 148, 1,               // 10094:  decode to LBu using decoder 148
                                             // 10094: }
  37, 7,                                     // 10099: case 0x25: {
  OPC_CheckPredicate, 27,                    // 10101:  check predicate 27
  OPC_Decode, 143, 15, 148, 1,               // 10103:  decode to LHu using decoder 148
                                             // 10103: }
  38, 7,                                     // 10108: case 0x26: {
  OPC_CheckPredicate, 31,                    // 10110:  check predicate 31
  OPC_Decode, 195, 15, 148, 1,               // 10112:  decode to LWR using decoder 148
                                             // 10112: }
  40, 7,                                     // 10117: case 0x28: {
  OPC_CheckPredicate, 27,                    // 10119:  check predicate 27
  OPC_Decode, 178, 19, 148, 1,               // 10121:  decode to SB using decoder 148
                                             // 10121: }
  41, 7,                                     // 10126: case 0x29: {
  OPC_CheckPredicate, 27,                    // 10128:  check predicate 27
  OPC_Decode, 244, 19, 148, 1,               // 10130:  decode to SH using decoder 148
                                             // 10130: }
  42, 7,                                     // 10135: case 0x2a: {
  OPC_CheckPredicate, 31,                    // 10137:  check predicate 31
  OPC_Decode, 220, 21, 148, 1,               // 10139:  decode to SWL using decoder 148
                                             // 10139: }
  43, 7,                                     // 10144: case 0x2b: {
  OPC_CheckPredicate, 27,                    // 10146:  check predicate 27
  OPC_Decode, 206, 21, 148, 1,               // 10148:  decode to SW using decoder 148
                                             // 10148: }
  46, 7,                                     // 10153: case 0x2e: {
  OPC_CheckPredicate, 31,                    // 10155:  check predicate 31
  OPC_Decode, 229, 21, 148, 1,               // 10157:  decode to SWR using decoder 148
                                             // 10157: }
  47, 7,                                     // 10162: case 0x2f: {
  OPC_CheckPredicate, 71,                    // 10164:  check predicate 71
  OPC_Decode, 219, 8, 221, 2,                // 10166:  decode to CACHE using decoder 349
                                             // 10166: }
  48, 7,                                     // 10171: case 0x30: {
  OPC_CheckPredicate, 72,                    // 10173:  check predicate 72
  OPC_Decode, 150, 15, 148, 1,               // 10175:  decode to LL using decoder 148
                                             // 10175: }
  49, 7,                                     // 10180: case 0x31: {
  OPC_CheckPredicate, 47,                    // 10182:  check predicate 47
  OPC_Decode, 173, 15, 222, 2,               // 10184:  decode to LWC1 using decoder 350
                                             // 10184: }
  50, 7,                                     // 10189: case 0x32: {
  OPC_CheckPredicate, 31,                    // 10191:  check predicate 31
  OPC_Decode, 175, 15, 223, 2,               // 10193:  decode to LWC2 using decoder 351
                                             // 10193: }
  51, 7,                                     // 10198: case 0x33: {
  OPC_CheckPredicate, 71,                    // 10200:  check predicate 71
  OPC_Decode, 235, 18, 221, 2,               // 10202:  decode to PREF using decoder 349
                                             // 10202: }
  53, 7,                                     // 10207: case 0x35: {
  OPC_CheckPredicate, 57,                    // 10209:  check predicate 57
  OPC_Decode, 238, 14, 222, 2,               // 10211:  decode to LDC1 using decoder 350
                                             // 10211: }
  54, 7,                                     // 10216: case 0x36: {
  OPC_CheckPredicate, 39,                    // 10218:  check predicate 39
  OPC_Decode, 243, 14, 223, 2,               // 10220:  decode to LDC2 using decoder 351
                                             // 10220: }
  56, 7,                                     // 10225: case 0x38: {
  OPC_CheckPredicate, 72,                    // 10227:  check predicate 72
  OPC_Decode, 186, 19, 148, 1,               // 10229:  decode to SC using decoder 148
                                             // 10229: }
  57, 7,                                     // 10234: case 0x39: {
  OPC_CheckPredicate, 47,                    // 10236:  check predicate 47
  OPC_Decode, 210, 21, 222, 2,               // 10238:  decode to SWC1 using decoder 350
                                             // 10238: }
  58, 7,                                     // 10243: case 0x3a: {
  OPC_CheckPredicate, 31,                    // 10245:  check predicate 31
  OPC_Decode, 212, 21, 223, 2,               // 10247:  decode to SWC2 using decoder 351
                                             // 10247: }
  61, 7,                                     // 10252: case 0x3d: {
  OPC_CheckPredicate, 57,                    // 10254:  check predicate 57
  OPC_Decode, 203, 19, 222, 2,               // 10256:  decode to SDC1 using decoder 350
                                             // 10256: }
  62, 0,                                     // 10261: case 0x3e: {
  OPC_CheckPredicate, 39,                    // 10263:  check predicate 39
  OPC_Decode, 208, 19, 223, 2,               // 10265:  decode to SDC2 using decoder 351
                                             // 10265: }
                                             // 10265: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMips32_64_PTR6432[33] = {
  OPC_SwitchField, 26, 6,                    //  0: switch Inst[31:26] {
  0, 10,                                     //  3: case 0x0: {
  OPC_CheckPredicate, 73,                    //  5:  check predicate 73
  OPC_CheckField, 0, 21, 8,                  //  7:  check Inst[20:0] == 0x8
  OPC_Decode, 205, 14, 51,                   // 11:  decode to JR64 using decoder 51
                                             // 11: }
  48, 7,                                     // 15: case 0x30: {
  OPC_CheckPredicate, 74,                    // 17:  check predicate 74
  OPC_Decode, 151, 15, 148, 1,               // 19:  decode to LL64 using decoder 148
                                             // 19: }
  56, 0,                                     // 24: case 0x38: {
  OPC_CheckPredicate, 74,                    // 26:  check predicate 74
  OPC_Decode, 187, 19, 148, 1,               // 28:  decode to SC64 using decoder 148
                                             // 28: }
                                             // 28: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMips32r6_64r632[1496] = {
  OPC_SwitchField, 26, 6,                    //    0: switch Inst[31:26] {
  0, 179, 2,                                 //    3: case 0x0: {
  OPC_SwitchField, 0, 6,                     //    6:  switch Inst[5:0] {
  5, 11,                                     //    9:  case 0x5: {
  OPC_CheckPredicate, 75,                    //   11:   check predicate 75
  OPC_CheckField, 8, 3, 0,                   //   13:   check Inst[10:8] == 0x0
  OPC_Decode, 162, 15, 187, 1,               //   17:   decode to LSA_R6 using decoder 187
                                             //   17:  }
  9, 11,                                     //   22:  case 0x9: {
  OPC_CheckPredicate, 75,                    //   24:   check predicate 75
  OPC_CheckField, 6, 15, 16,                 //   26:   check Inst[20:6] == 0x10
  OPC_Decode, 213, 14, 188, 1,               //   30:   decode to JR_HB_R6 using decoder 188
                                             //   30:  }
  14, 7,                                     //   35:  case 0xe: {
  OPC_CheckPredicate, 76,                    //   37:   check predicate 76
  OPC_Decode, 202, 19, 190, 1,               //   39:   decode to SDBBP_R6 using decoder 190
                                             //   39:  }
  16, 14,                                    //   44:  case 0x10: {
  OPC_CheckPredicate, 75,                    //   46:   check predicate 75
  OPC_CheckField, 16, 5, 0,                  //   48:   check Inst[20:16] == 0x0
  OPC_CheckField, 6, 5, 1,                   //   52:   check Inst[10:6] == 0x1
  OPC_Decode, 167, 9, 52,                    //   56:   decode to CLZ_R6 using decoder 52
                                             //   56:  }
  17, 14,                                    //   60:  case 0x11: {
  OPC_CheckPredicate, 75,                    //   62:   check predicate 75
  OPC_CheckField, 16, 5, 0,                  //   64:   check Inst[20:16] == 0x0
  OPC_CheckField, 6, 5, 1,                   //   68:   check Inst[10:6] == 0x1
  OPC_Decode, 147, 9, 52,                    //   72:   decode to CLO_R6 using decoder 52
                                             //   72:  }
  18, 14,                                    //   76:  case 0x12: {
  OPC_CheckPredicate, 77,                    //   78:   check predicate 77
  OPC_CheckField, 16, 5, 0,                  //   80:   check Inst[20:16] == 0x0
  OPC_CheckField, 6, 5, 1,                   //   84:   check Inst[10:6] == 0x1
  OPC_Decode, 167, 11, 53,                   //   88:   decode to DCLZ_R6 using decoder 53
                                             //   88:  }
  19, 14,                                    //   92:  case 0x13: {
  OPC_CheckPredicate, 77,                    //   94:   check predicate 77
  OPC_CheckField, 16, 5, 0,                  //   96:   check Inst[20:16] == 0x0
  OPC_CheckField, 6, 5, 1,                   //  100:   check Inst[10:6] == 0x1
  OPC_Decode, 165, 11, 53,                   //  104:   decode to DCLO_R6 using decoder 53
                                             //  104:  }
  21, 11,                                    //  108:  case 0x15: {
  OPC_CheckPredicate, 77,                    //  110:   check predicate 77
  OPC_CheckField, 8, 3, 0,                   //  112:   check Inst[10:8] == 0x0
  OPC_Decode, 196, 11, 196, 1,               //  116:   decode to DLSA_R6 using decoder 196
                                             //  116:  }
  24, 19,                                    //  121:  case 0x18: {
  OPC_SwitchField, 6, 5,                     //  123:   switch Inst[10:6] {
  2, 6,                                      //  126:   case 0x2: {
  OPC_CheckPredicate, 76,                    //  128:    check predicate 76
  OPC_Decode, 128, 18, 67,                   //  130:    decode to MUL_R6 using decoder 67
                                             //  130:   }
  3, 0,                                      //  134:   case 0x3: {
  OPC_CheckPredicate, 76,                    //  136:    check predicate 76
  OPC_Decode, 208, 17, 67,                   //  138:    decode to MUH using decoder 67
                                             //  138:   }
                                             //  138:   } // switch Inst[10:6]
                                             //  138:  }
  25, 19,                                    //  142:  case 0x19: {
  OPC_SwitchField, 6, 5,                     //  144:   switch Inst[10:6] {
  2, 6,                                      //  147:   case 0x2: {
  OPC_CheckPredicate, 76,                    //  149:    check predicate 76
  OPC_Decode, 244, 17, 67,                   //  151:    decode to MULU using decoder 67
                                             //  151:   }
  3, 0,                                      //  155:   case 0x3: {
  OPC_CheckPredicate, 76,                    //  157:    check predicate 76
  OPC_Decode, 209, 17, 67,                   //  159:    decode to MUHU using decoder 67
                                             //  159:   }
                                             //  159:   } // switch Inst[10:6]
                                             //  159:  }
  26, 19,                                    //  163:  case 0x1a: {
  OPC_SwitchField, 6, 5,                     //  165:   switch Inst[10:6] {
  2, 6,                                      //  168:   case 0x2: {
  OPC_CheckPredicate, 76,                    //  170:    check predicate 76
  OPC_Decode, 181, 11, 67,                   //  172:    decode to DIV using decoder 67
                                             //  172:   }
  3, 0,                                      //  176:   case 0x3: {
  OPC_CheckPredicate, 76,                    //  178:    check predicate 76
  OPC_Decode, 214, 16, 67,                   //  180:    decode to MOD using decoder 67
                                             //  180:   }
                                             //  180:   } // switch Inst[10:6]
                                             //  180:  }
  27, 19,                                    //  184:  case 0x1b: {
  OPC_SwitchField, 6, 5,                     //  186:   switch Inst[10:6] {
  2, 6,                                      //  189:   case 0x2: {
  OPC_CheckPredicate, 76,                    //  191:    check predicate 76
  OPC_Decode, 182, 11, 67,                   //  193:    decode to DIVU using decoder 67
                                             //  193:   }
  3, 0,                                      //  197:   case 0x3: {
  OPC_CheckPredicate, 76,                    //  199:    check predicate 76
  OPC_Decode, 217, 16, 67,                   //  201:    decode to MODU using decoder 67
                                             //  201:   }
                                             //  201:   } // switch Inst[10:6]
                                             //  201:  }
  28, 19,                                    //  205:  case 0x1c: {
  OPC_SwitchField, 6, 5,                     //  207:   switch Inst[10:6] {
  2, 6,                                      //  210:   case 0x2: {
  OPC_CheckPredicate, 77,                    //  212:    check predicate 77
  OPC_Decode, 216, 11, 50,                   //  214:    decode to DMUL_R6 using decoder 50
                                             //  214:   }
  3, 0,                                      //  218:   case 0x3: {
  OPC_CheckPredicate, 77,                    //  220:    check predicate 77
  OPC_Decode, 210, 11, 50,                   //  222:    decode to DMUH using decoder 50
                                             //  222:   }
                                             //  222:   } // switch Inst[10:6]
                                             //  222:  }
  29, 19,                                    //  226:  case 0x1d: {
  OPC_SwitchField, 6, 5,                     //  228:   switch Inst[10:6] {
  2, 6,                                      //  231:   case 0x2: {
  OPC_CheckPredicate, 77,                    //  233:    check predicate 77
  OPC_Decode, 215, 11, 50,                   //  235:    decode to DMULU using decoder 50
                                             //  235:   }
  3, 0,                                      //  239:   case 0x3: {
  OPC_CheckPredicate, 77,                    //  241:    check predicate 77
  OPC_Decode, 211, 11, 50,                   //  243:    decode to DMUHU using decoder 50
                                             //  243:   }
                                             //  243:   } // switch Inst[10:6]
                                             //  243:  }
  30, 19,                                    //  247:  case 0x1e: {
  OPC_SwitchField, 6, 5,                     //  249:   switch Inst[10:6] {
  2, 6,                                      //  252:   case 0x2: {
  OPC_CheckPredicate, 77,                    //  254:    check predicate 77
  OPC_Decode, 168, 11, 50,                   //  256:    decode to DDIV using decoder 50
                                             //  256:   }
  3, 0,                                      //  260:   case 0x3: {
  OPC_CheckPredicate, 77,                    //  262:    check predicate 77
  OPC_Decode, 202, 11, 50,                   //  264:    decode to DMOD using decoder 50
                                             //  264:   }
                                             //  264:   } // switch Inst[10:6]
                                             //  264:  }
  31, 19,                                    //  268:  case 0x1f: {
  OPC_SwitchField, 6, 5,                     //  270:   switch Inst[10:6] {
  2, 6,                                      //  273:   case 0x2: {
  OPC_CheckPredicate, 77,                    //  275:    check predicate 77
  OPC_Decode, 169, 11, 50,                   //  277:    decode to DDIVU using decoder 50
                                             //  277:   }
  3, 0,                                      //  281:   case 0x3: {
  OPC_CheckPredicate, 77,                    //  283:    check predicate 77
  OPC_Decode, 203, 11, 50,                   //  285:    decode to DMODU using decoder 50
                                             //  285:   }
                                             //  285:   } // switch Inst[10:6]
                                             //  285:  }
  53, 10,                                    //  289:  case 0x35: {
  OPC_CheckPredicate, 78,                    //  291:   check predicate 78
  OPC_CheckField, 6, 5, 0,                   //  293:   check Inst[10:6] == 0x0
  OPC_Decode, 224, 19, 67,                   //  297:   decode to SELEQZ using decoder 67
                                             //  297:  }
  55, 0,                                     //  301:  case 0x37: {
  OPC_CheckPredicate, 78,                    //  303:   check predicate 78
  OPC_CheckField, 6, 5, 0,                   //  305:   check Inst[10:6] == 0x0
  OPC_Decode, 231, 19, 67,                   //  309:   decode to SELNEZ using decoder 67
                                             //  309:  }
                                             //  309:  } // switch Inst[5:0]
                                             //  309: }
  1, 63,                                     //  313: case 0x1: {
  OPC_SwitchField, 16, 5,                    //  315:  switch Inst[20:16] {
  6, 7,                                      //  318:  case 0x6: {
  OPC_CheckPredicate, 77,                    //  320:   check predicate 77
  OPC_Decode, 159, 11, 224, 2,               //  322:   decode to DAHI using decoder 352
                                             //  322:  }
  16, 14,                                    //  327:  case 0x10: {
  OPC_CheckPredicate, 75,                    //  329:   check predicate 75
  OPC_CheckField, 21, 5, 0,                  //  331:   check Inst[25:21] == 0x0
  OPC_CheckField, 0, 16, 0,                  //  335:   check Inst[15:0] == 0x0
  OPC_Decode, 135, 18, 10,                   //  339:   decode to NAL using decoder 10
                                             //  339:  }
  17, 11,                                    //  343:  case 0x11: {
  OPC_CheckPredicate, 75,                    //  345:   check predicate 75
  OPC_CheckField, 21, 5, 0,                  //  347:   check Inst[25:21] == 0x0
  OPC_Decode, 152, 7, 200, 1,                //  351:   decode to BAL using decoder 200
                                             //  351:  }
  23, 11,                                    //  356:  case 0x17: {
  OPC_CheckPredicate, 76,                    //  358:   check predicate 76
  OPC_CheckField, 21, 5, 0,                  //  360:   check Inst[25:21] == 0x0
  OPC_Decode, 175, 20, 225, 2,               //  364:   decode to SIGRIE using decoder 353
                                             //  364:  }
  30, 0,                                     //  369:  case 0x1e: {
  OPC_CheckPredicate, 77,                    //  371:   check predicate 77
  OPC_Decode, 161, 11, 224, 2,               //  373:   decode to DATI using decoder 352
                                             //  373:  }
                                             //  373:  } // switch Inst[20:16]
                                             //  373: }
  6, 7,                                      //  378: case 0x6: {
  OPC_CheckPredicate, 76,                    //  380:  check predicate 76
  OPC_Decode, 210, 7, 226, 2,                //  382:  decode to BGEZALC using decoder 354
                                             //  382: }
  7, 7,                                      //  387: case 0x7: {
  OPC_CheckPredicate, 76,                    //  389:  check predicate 76
  OPC_Decode, 139, 8, 227, 2,                //  391:  decode to BLTZALC using decoder 355
                                             //  391: }
  8, 7,                                      //  396: case 0x8: {
  OPC_CheckPredicate, 76,                    //  398:  check predicate 76
  OPC_Decode, 188, 7, 228, 2,                //  400:  decode to BEQC using decoder 356
                                             //  400: }
  15, 7,                                     //  405: case 0xf: {
  OPC_CheckPredicate, 75,                    //  407:  check predicate 75
  OPC_Decode, 249, 6, 205, 1,                //  409:  decode to AUI using decoder 205
                                             //  409: }
  16, 27,                                    //  414: case 0x10: {
  OPC_SwitchField, 0, 16,                    //  416:  switch Inst[15:0] {
  4, 10,                                     //  419:  case 0x4: {
  OPC_CheckPredicate, 75,                    //  421:   check predicate 75
  OPC_CheckField, 21, 5, 11,                 //  423:   check Inst[25:21] == 0xb
  OPC_Decode, 176, 12, 99,                   //  427:   decode to EVP using decoder 99
                                             //  427:  }
  36, 0,                                     //  431:  case 0x24: {
  OPC_CheckPredicate, 75,                    //  433:   check predicate 75
  OPC_CheckField, 21, 5, 11,                 //  435:   check Inst[25:21] == 0xb
  OPC_Decode, 159, 12, 99,                   //  439:   decode to DVP using decoder 99
                                             //  439:  }
                                             //  439:  } // switch Inst[15:0]
                                             //  439: }
  17, 160, 4,                                //  443: case 0x11: {
  OPC_SwitchField, 21, 5,                    //  446:  switch Inst[25:21] {
  9, 7,                                      //  449:  case 0x9: {
  OPC_CheckPredicate, 79,                    //  451:   check predicate 79
  OPC_Decode, 163, 7, 229, 2,                //  453:   decode to BC1EQZ using decoder 357
                                             //  453:  }
  13, 7,                                     //  458:  case 0xd: {
  OPC_CheckPredicate, 79,                    //  460:   check predicate 79
  OPC_Decode, 168, 7, 229, 2,                //  462:   decode to BC1NEZ using decoder 357
                                             //  462:  }
  16, 110,                                   //  467:  case 0x10: {
  OPC_SwitchField, 0, 6,                     //  469:   switch Inst[5:0] {
  16, 7,                                     //  472:   case 0x10: {
  OPC_CheckPredicate, 79,                    //  474:    check predicate 79
  OPC_Decode, 240, 19, 230, 2,               //  476:    decode to SEL_S using decoder 358
                                             //  476:   }
  20, 7,                                     //  481:   case 0x14: {
  OPC_CheckPredicate, 79,                    //  483:    check predicate 79
  OPC_Decode, 229, 19, 220, 1,               //  485:    decode to SELEQZ_S using decoder 220
                                             //  485:   }
  23, 7,                                     //  490:   case 0x17: {
  OPC_CheckPredicate, 79,                    //  492:    check predicate 79
  OPC_Decode, 236, 19, 220, 1,               //  494:    decode to SELNEZ_S using decoder 220
                                             //  494:   }
  24, 7,                                     //  499:   case 0x18: {
  OPC_CheckPredicate, 79,                    //  501:    check predicate 79
  OPC_Decode, 225, 15, 231, 2,               //  503:    decode to MADDF_S using decoder 359
                                             //  503:   }
  25, 7,                                     //  508:   case 0x19: {
  OPC_CheckPredicate, 79,                    //  510:    check predicate 79
  OPC_Decode, 148, 17, 231, 2,               //  512:    decode to MSUBF_S using decoder 359
                                             //  512:   }
  26, 11,                                    //  517:   case 0x1a: {
  OPC_CheckPredicate, 79,                    //  519:    check predicate 79
  OPC_CheckField, 16, 5, 0,                  //  521:    check Inst[20:16] == 0x0
  OPC_Decode, 143, 19, 221, 1,               //  525:    decode to RINT_S using decoder 221
                                             //  525:   }
  27, 11,                                    //  530:   case 0x1b: {
  OPC_CheckPredicate, 79,                    //  532:    check predicate 79
  OPC_CheckField, 16, 5, 0,                  //  534:    check Inst[20:16] == 0x0
  OPC_Decode, 254, 8, 221, 1,                //  538:    decode to CLASS_S using decoder 221
                                             //  538:   }
  28, 7,                                     //  543:   case 0x1c: {
  OPC_CheckPredicate, 79,                    //  545:    check predicate 79
  OPC_Decode, 204, 16, 220, 1,               //  547:    decode to MIN_S using decoder 220
                                             //  547:   }
  29, 7,                                     //  552:   case 0x1d: {
  OPC_CheckPredicate, 79,                    //  554:    check predicate 79
  OPC_Decode, 188, 16, 220, 1,               //  556:    decode to MINA_S using decoder 220
                                             //  556:   }
  30, 7,                                     //  561:   case 0x1e: {
  OPC_CheckPredicate, 79,                    //  563:    check predicate 79
  OPC_Decode, 145, 16, 220, 1,               //  565:    decode to MAX_S using decoder 220
                                             //  565:   }
  31, 0,                                     //  570:   case 0x1f: {
  OPC_CheckPredicate, 79,                    //  572:    check predicate 79
  OPC_Decode, 129, 16, 220, 1,               //  574:    decode to MAXA_S using decoder 220
                                             //  574:   }
                                             //  574:   } // switch Inst[5:0]
                                             //  574:  }
  17, 110,                                   //  579:  case 0x11: {
  OPC_SwitchField, 0, 6,                     //  581:   switch Inst[5:0] {
  16, 7,                                     //  584:   case 0x10: {
  OPC_CheckPredicate, 79,                    //  586:    check predicate 79
  OPC_Decode, 238, 19, 232, 2,               //  588:    decode to SEL_D using decoder 360
                                             //  588:   }
  20, 7,                                     //  593:   case 0x14: {
  OPC_CheckPredicate, 79,                    //  595:    check predicate 79
  OPC_Decode, 226, 19, 233, 2,               //  597:    decode to SELEQZ_D using decoder 361
                                             //  597:   }
  23, 7,                                     //  602:   case 0x17: {
  OPC_CheckPredicate, 79,                    //  604:    check predicate 79
  OPC_Decode, 233, 19, 233, 2,               //  606:    decode to SELNEZ_D using decoder 361
                                             //  606:   }
  24, 7,                                     //  611:   case 0x18: {
  OPC_CheckPredicate, 79,                    //  613:    check predicate 79
  OPC_Decode, 223, 15, 234, 2,               //  615:    decode to MADDF_D using decoder 362
                                             //  615:   }
  25, 7,                                     //  620:   case 0x19: {
  OPC_CheckPredicate, 79,                    //  622:    check predicate 79
  OPC_Decode, 146, 17, 234, 2,               //  624:    decode to MSUBF_D using decoder 362
                                             //  624:   }
  26, 11,                                    //  629:   case 0x1a: {
  OPC_CheckPredicate, 79,                    //  631:    check predicate 79
  OPC_CheckField, 16, 5, 0,                  //  633:    check Inst[20:16] == 0x0
  OPC_Decode, 141, 19, 232, 1,               //  637:    decode to RINT_D using decoder 232
                                             //  637:   }
  27, 11,                                    //  642:   case 0x1b: {
  OPC_CheckPredicate, 79,                    //  644:    check predicate 79
  OPC_CheckField, 16, 5, 0,                  //  646:    check Inst[20:16] == 0x0
  OPC_Decode, 252, 8, 232, 1,                //  650:    decode to CLASS_D using decoder 232
                                             //  650:   }
  28, 7,                                     //  655:   case 0x1c: {
  OPC_CheckPredicate, 79,                    //  657:    check predicate 79
  OPC_Decode, 202, 16, 233, 2,               //  659:    decode to MIN_D using decoder 361
                                             //  659:   }
  29, 7,                                     //  664:   case 0x1d: {
  OPC_CheckPredicate, 79,                    //  666:    check predicate 79
  OPC_Decode, 186, 16, 233, 2,               //  668:    decode to MINA_D using decoder 361
                                             //  668:   }
  30, 7,                                     //  673:   case 0x1e: {
  OPC_CheckPredicate, 79,                    //  675:    check predicate 79
  OPC_Decode, 143, 16, 233, 2,               //  677:    decode to MAX_D using decoder 361
                                             //  677:   }
  31, 0,                                     //  682:   case 0x1f: {
  OPC_CheckPredicate, 79,                    //  684:    check predicate 79
  OPC_Decode, 255, 15, 233, 2,               //  686:    decode to MAXA_D using decoder 361
                                             //  686:   }
                                             //  686:   } // switch Inst[5:0]
                                             //  686:  }
  20, 147, 1,                                //  691:  case 0x14: {
  OPC_SwitchField, 0, 6,                     //  694:   switch Inst[5:0] {
  0, 7,                                      //  697:   case 0x0: {
  OPC_CheckPredicate, 79,                    //  699:    check predicate 79
  OPC_Decode, 195, 9, 235, 2,                //  701:    decode to CMP_F_S using decoder 363
                                             //  701:   }
  1, 7,                                      //  706:   case 0x1: {
  OPC_CheckPredicate, 79,                    //  708:    check predicate 79
  OPC_Decode, 254, 9, 235, 2,                //  710:    decode to CMP_UN_S using decoder 363
                                             //  710:   }
  2, 7,                                      //  715:   case 0x2: {
  OPC_CheckPredicate, 79,                    //  717:    check predicate 79
  OPC_Decode, 192, 9, 235, 2,                //  719:    decode to CMP_EQ_S using decoder 363
                                             //  719:   }
  3, 7,                                      //  724:   case 0x3: {
  OPC_CheckPredicate, 79,                    //  726:    check predicate 79
  OPC_Decode, 242, 9, 235, 2,                //  728:    decode to CMP_UEQ_S using decoder 363
                                             //  728:   }
  4, 7,                                      //  733:   case 0x4: {
  OPC_CheckPredicate, 79,                    //  735:    check predicate 79
  OPC_Decode, 206, 9, 235, 2,                //  737:    decode to CMP_LT_S using decoder 363
                                             //  737:   }
  5, 7,                                      //  742:   case 0x5: {
  OPC_CheckPredicate, 79,                    //  744:    check predicate 79
  OPC_Decode, 250, 9, 235, 2,                //  746:    decode to CMP_ULT_S using decoder 363
                                             //  746:   }
  6, 7,                                      //  751:   case 0x6: {
  OPC_CheckPredicate, 79,                    //  753:    check predicate 79
  OPC_Decode, 200, 9, 235, 2,                //  755:    decode to CMP_LE_S using decoder 363
                                             //  755:   }
  7, 7,                                      //  760:   case 0x7: {
  OPC_CheckPredicate, 79,                    //  762:    check predicate 79
  OPC_Decode, 246, 9, 235, 2,                //  764:    decode to CMP_ULE_S using decoder 363
                                             //  764:   }
  8, 7,                                      //  769:   case 0x8: {
  OPC_CheckPredicate, 79,                    //  771:    check predicate 79
  OPC_Decode, 210, 9, 235, 2,                //  773:    decode to CMP_SAF_S using decoder 363
                                             //  773:   }
  9, 7,                                      //  778:   case 0x9: {
  OPC_CheckPredicate, 79,                    //  780:    check predicate 79
  OPC_Decode, 238, 9, 235, 2,                //  782:    decode to CMP_SUN_S using decoder 363
                                             //  782:   }
  10, 7,                                     //  787:   case 0xa: {
  OPC_CheckPredicate, 79,                    //  789:    check predicate 79
  OPC_Decode, 214, 9, 235, 2,                //  791:    decode to CMP_SEQ_S using decoder 363
                                             //  791:   }
  11, 7,                                     //  796:   case 0xb: {
  OPC_CheckPredicate, 79,                    //  798:    check predicate 79
  OPC_Decode, 226, 9, 235, 2,                //  800:    decode to CMP_SUEQ_S using decoder 363
                                             //  800:   }
  12, 7,                                     //  805:   case 0xc: {
  OPC_CheckPredicate, 79,                    //  807:    check predicate 79
  OPC_Decode, 222, 9, 235, 2,                //  809:    decode to CMP_SLT_S using decoder 363
                                             //  809:   }
  13, 7,                                     //  814:   case 0xd: {
  OPC_CheckPredicate, 79,                    //  816:    check predicate 79
  OPC_Decode, 234, 9, 235, 2,                //  818:    decode to CMP_SULT_S using decoder 363
                                             //  818:   }
  14, 7,                                     //  823:   case 0xe: {
  OPC_CheckPredicate, 79,                    //  825:    check predicate 79
  OPC_Decode, 218, 9, 235, 2,                //  827:    decode to CMP_SLE_S using decoder 363
                                             //  827:   }
  15, 0,                                     //  832:   case 0xf: {
  OPC_CheckPredicate, 79,                    //  834:    check predicate 79
  OPC_Decode, 230, 9, 235, 2,                //  836:    decode to CMP_SULE_S using decoder 363
                                             //  836:   }
                                             //  836:   } // switch Inst[5:0]
                                             //  836:  }
  21, 0,                                     //  841:  case 0x15: {
  OPC_SwitchField, 0, 6,                     //  843:   switch Inst[5:0] {
  0, 7,                                      //  846:   case 0x0: {
  OPC_CheckPredicate, 79,                    //  848:    check predicate 79
  OPC_Decode, 194, 9, 236, 2,                //  850:    decode to CMP_F_D using decoder 364
                                             //  850:   }
  1, 7,                                      //  855:   case 0x1: {
  OPC_CheckPredicate, 79,                    //  857:    check predicate 79
  OPC_Decode, 252, 9, 236, 2,                //  859:    decode to CMP_UN_D using decoder 364
                                             //  859:   }
  2, 7,                                      //  864:   case 0x2: {
  OPC_CheckPredicate, 79,                    //  866:    check predicate 79
  OPC_Decode, 188, 9, 236, 2,                //  868:    decode to CMP_EQ_D using decoder 364
                                             //  868:   }
  3, 7,                                      //  873:   case 0x3: {
  OPC_CheckPredicate, 79,                    //  875:    check predicate 79
  OPC_Decode, 240, 9, 236, 2,                //  877:    decode to CMP_UEQ_D using decoder 364
                                             //  877:   }
  4, 7,                                      //  882:   case 0x4: {
  OPC_CheckPredicate, 79,                    //  884:    check predicate 79
  OPC_Decode, 202, 9, 236, 2,                //  886:    decode to CMP_LT_D using decoder 364
                                             //  886:   }
  5, 7,                                      //  891:   case 0x5: {
  OPC_CheckPredicate, 79,                    //  893:    check predicate 79
  OPC_Decode, 248, 9, 236, 2,                //  895:    decode to CMP_ULT_D using decoder 364
                                             //  895:   }
  6, 7,                                      //  900:   case 0x6: {
  OPC_CheckPredicate, 79,                    //  902:    check predicate 79
  OPC_Decode, 196, 9, 236, 2,                //  904:    decode to CMP_LE_D using decoder 364
                                             //  904:   }
  7, 7,                                      //  909:   case 0x7: {
  OPC_CheckPredicate, 79,                    //  911:    check predicate 79
  OPC_Decode, 244, 9, 236, 2,                //  913:    decode to CMP_ULE_D using decoder 364
                                             //  913:   }
  8, 7,                                      //  918:   case 0x8: {
  OPC_CheckPredicate, 79,                    //  920:    check predicate 79
  OPC_Decode, 208, 9, 236, 2,                //  922:    decode to CMP_SAF_D using decoder 364
                                             //  922:   }
  9, 7,                                      //  927:   case 0x9: {
  OPC_CheckPredicate, 79,                    //  929:    check predicate 79
  OPC_Decode, 236, 9, 236, 2,                //  931:    decode to CMP_SUN_D using decoder 364
                                             //  931:   }
  10, 7,                                     //  936:   case 0xa: {
  OPC_CheckPredicate, 79,                    //  938:    check predicate 79
  OPC_Decode, 212, 9, 236, 2,                //  940:    decode to CMP_SEQ_D using decoder 364
                                             //  940:   }
  11, 7,                                     //  945:   case 0xb: {
  OPC_CheckPredicate, 79,                    //  947:    check predicate 79
  OPC_Decode, 224, 9, 236, 2,                //  949:    decode to CMP_SUEQ_D using decoder 364
                                             //  949:   }
  12, 7,                                     //  954:   case 0xc: {
  OPC_CheckPredicate, 79,                    //  956:    check predicate 79
  OPC_Decode, 220, 9, 236, 2,                //  958:    decode to CMP_SLT_D using decoder 364
                                             //  958:   }
  13, 7,                                     //  963:   case 0xd: {
  OPC_CheckPredicate, 79,                    //  965:    check predicate 79
  OPC_Decode, 232, 9, 236, 2,                //  967:    decode to CMP_SULT_D using decoder 364
                                             //  967:   }
  14, 7,                                     //  972:   case 0xe: {
  OPC_CheckPredicate, 79,                    //  974:    check predicate 79
  OPC_Decode, 216, 9, 236, 2,                //  976:    decode to CMP_SLE_D using decoder 364
                                             //  976:   }
  15, 0,                                     //  981:   case 0xf: {
  OPC_CheckPredicate, 79,                    //  983:    check predicate 79
  OPC_Decode, 228, 9, 236, 2,                //  985:    decode to CMP_SULE_D using decoder 364
                                             //  985:   }
                                             //  985:   } // switch Inst[5:0]
                                             //  985:  }
                                             //  985:  } // switch Inst[25:21]
                                             //  985: }
  18, 57,                                    //  990: case 0x12: {
  OPC_SwitchField, 21, 5,                    //  992:  switch Inst[25:21] {
  9, 7,                                      //  995:  case 0x9: {
  OPC_CheckPredicate, 76,                    //  997:   check predicate 76
  OPC_Decode, 173, 7, 237, 2,                //  999:   decode to BC2EQZ using decoder 365
                                             //  999:  }
  10, 7,                                     // 1004:  case 0xa: {
  OPC_CheckPredicate, 76,                    // 1006:   check predicate 76
  OPC_Decode, 177, 15, 238, 2,               // 1008:   decode to LWC2_R6 using decoder 366
                                             // 1008:  }
  11, 7,                                     // 1013:  case 0xb: {
  OPC_CheckPredicate, 76,                    // 1015:   check predicate 76
  OPC_Decode, 214, 21, 238, 2,               // 1017:   decode to SWC2_R6 using decoder 366
                                             // 1017:  }
  13, 7,                                     // 1022:  case 0xd: {
  OPC_CheckPredicate, 76,                    // 1024:   check predicate 76
  OPC_Decode, 175, 7, 237, 2,                // 1026:   decode to BC2NEZ using decoder 365
                                             // 1026:  }
  14, 7,                                     // 1031:  case 0xe: {
  OPC_CheckPredicate, 76,                    // 1033:   check predicate 76
  OPC_Decode, 245, 14, 238, 2,               // 1035:   decode to LDC2_R6 using decoder 366
                                             // 1035:  }
  15, 0,                                     // 1040:  case 0xf: {
  OPC_CheckPredicate, 76,                    // 1042:   check predicate 76
  OPC_Decode, 210, 19, 238, 2,               // 1044:   decode to SDC2_R6 using decoder 366
                                             // 1044:  }
                                             // 1044:  } // switch Inst[25:21]
                                             // 1044: }
  22, 7,                                     // 1049: case 0x16: {
  OPC_CheckPredicate, 76,                    // 1051:  check predicate 76
  OPC_Decode, 215, 7, 239, 2,                // 1053:  decode to BGEZC using decoder 367
                                             // 1053: }
  23, 7,                                     // 1058: case 0x17: {
  OPC_CheckPredicate, 76,                    // 1060:  check predicate 76
  OPC_Decode, 144, 8, 240, 2,                // 1062:  decode to BLTZC using decoder 368
                                             // 1062: }
  24, 7,                                     // 1067: case 0x18: {
  OPC_CheckPredicate, 76,                    // 1069:  check predicate 76
  OPC_Decode, 155, 8, 241, 2,                // 1071:  decode to BNEC using decoder 369
                                             // 1071: }
  29, 7,                                     // 1076: case 0x1d: {
  OPC_CheckPredicate, 77,                    // 1078:  check predicate 77
  OPC_Decode, 162, 11, 242, 2,               // 1080:  decode to DAUI using decoder 370
                                             // 1080: }
  31, 235, 1,                                // 1085: case 0x1f: {
  OPC_SwitchField, 0, 6,                     // 1088:  switch Inst[5:0] {
  15, 75,                                    // 1091:  case 0xf: {
  OPC_SwitchField, 6, 10,                    // 1093:   switch Inst[15:6] {
  0, 7,                                      // 1096:   case 0x0: {
  OPC_CheckPredicate, 80,                    // 1098:    check predicate 80
  OPC_Decode, 135, 10, 243, 2,               // 1100:    decode to CRC32B using decoder 371
                                             // 1100:   }
  1, 7,                                      // 1105:   case 0x1: {
  OPC_CheckPredicate, 80,                    // 1107:    check predicate 80
  OPC_Decode, 141, 10, 243, 2,               // 1109:    decode to CRC32H using decoder 371
                                             // 1109:   }
  2, 7,                                      // 1114:   case 0x2: {
  OPC_CheckPredicate, 80,                    // 1116:    check predicate 80
  OPC_Decode, 142, 10, 243, 2,               // 1118:    decode to CRC32W using decoder 371
                                             // 1118:   }
  3, 7,                                      // 1123:   case 0x3: {
  OPC_CheckPredicate, 81,                    // 1125:    check predicate 81
  OPC_Decode, 140, 10, 243, 2,               // 1127:    decode to CRC32D using decoder 371
                                             // 1127:   }
  4, 7,                                      // 1132:   case 0x4: {
  OPC_CheckPredicate, 80,                    // 1134:    check predicate 80
  OPC_Decode, 136, 10, 243, 2,               // 1136:    decode to CRC32CB using decoder 371
                                             // 1136:   }
  5, 7,                                      // 1141:   case 0x5: {
  OPC_CheckPredicate, 80,                    // 1143:    check predicate 80
  OPC_Decode, 138, 10, 243, 2,               // 1145:    decode to CRC32CH using decoder 371
                                             // 1145:   }
  6, 7,                                      // 1150:   case 0x6: {
  OPC_CheckPredicate, 80,                    // 1152:    check predicate 80
  OPC_Decode, 139, 10, 243, 2,               // 1154:    decode to CRC32CW using decoder 371
                                             // 1154:   }
  7, 0,                                      // 1159:   case 0x7: {
  OPC_CheckPredicate, 81,                    // 1161:    check predicate 81
  OPC_Decode, 137, 10, 243, 2,               // 1163:    decode to CRC32CD using decoder 371
                                             // 1163:   }
                                             // 1163:   } // switch Inst[15:6]
                                             // 1163:  }
  32, 29,                                    // 1168:  case 0x20: {
  OPC_SwitchField, 8, 3,                     // 1170:   switch Inst[10:8] {
  0, 15,                                     // 1173:   case 0x0: {
  OPC_CheckPredicate, 75,                    // 1175:    check predicate 75
  OPC_CheckField, 21, 5, 0,                  // 1177:    check Inst[25:21] == 0x0
  OPC_CheckField, 6, 2, 0,                   // 1181:    check Inst[7:6] == 0x0
  OPC_Decode, 247, 7, 206, 2,                // 1185:    decode to BITSWAP using decoder 334
                                             // 1185:   }
  2, 0,                                      // 1190:   case 0x2: {
  OPC_CheckPredicate, 75,                    // 1192:    check predicate 75
  OPC_Decode, 221, 6, 244, 2,                // 1194:    decode to ALIGN using decoder 372
                                             // 1194:   }
                                             // 1194:   } // switch Inst[10:8]
                                             // 1194:  }
  36, 29,                                    // 1199:  case 0x24: {
  OPC_SwitchField, 9, 2,                     // 1201:   switch Inst[10:9] {
  0, 15,                                     // 1204:   case 0x0: {
  OPC_CheckPredicate, 77,                    // 1206:    check predicate 77
  OPC_CheckField, 21, 5, 0,                  // 1208:    check Inst[25:21] == 0x0
  OPC_CheckField, 6, 3, 0,                   // 1212:    check Inst[8:6] == 0x0
  OPC_Decode, 163, 11, 245, 2,               // 1216:    decode to DBITSWAP using decoder 373
                                             // 1216:   }
  1, 0,                                      // 1221:   case 0x1: {
  OPC_CheckPredicate, 77,                    // 1223:    check predicate 77
  OPC_Decode, 160, 11, 246, 2,               // 1225:    decode to DALIGN using decoder 374
                                             // 1225:   }
                                             // 1225:   } // switch Inst[10:9]
                                             // 1225:  }
  37, 11,                                    // 1230:  case 0x25: {
  OPC_CheckPredicate, 76,                    // 1232:   check predicate 76
  OPC_CheckField, 6, 1, 0,                   // 1234:   check Inst[6] == 0x0
  OPC_Decode, 224, 8, 211, 2,                // 1238:   decode to CACHE_R6 using decoder 339
                                             // 1238:  }
  38, 7,                                     // 1243:  case 0x26: {
  OPC_CheckPredicate, 82,                    // 1245:   check predicate 82
  OPC_Decode, 195, 19, 247, 2,               // 1247:   decode to SC_R6 using decoder 375
                                             // 1247:  }
  39, 7,                                     // 1252:  case 0x27: {
  OPC_CheckPredicate, 75,                    // 1254:   check predicate 75
  OPC_Decode, 190, 19, 247, 2,               // 1256:   decode to SCD_R6 using decoder 375
                                             // 1256:  }
  53, 11,                                    // 1261:  case 0x35: {
  OPC_CheckPredicate, 76,                    // 1263:   check predicate 76
  OPC_CheckField, 6, 1, 0,                   // 1265:   check Inst[6] == 0x0
  OPC_Decode, 241, 18, 211, 2,               // 1269:   decode to PREF_R6 using decoder 339
                                             // 1269:  }
  54, 7,                                     // 1274:  case 0x36: {
  OPC_CheckPredicate, 82,                    // 1276:   check predicate 82
  OPC_Decode, 159, 15, 247, 2,               // 1278:   decode to LL_R6 using decoder 375
                                             // 1278:  }
  55, 7,                                     // 1283:  case 0x37: {
  OPC_CheckPredicate, 77,                    // 1285:   check predicate 77
  OPC_Decode, 154, 15, 247, 2,               // 1287:   decode to LLD_R6 using decoder 375
                                             // 1287:  }
  61, 0,                                     // 1292:  case 0x3d: {
  OPC_SwitchField, 6, 2,                     // 1294:   switch Inst[7:6] {
  0, 11,                                     // 1297:   case 0x0: {
  OPC_CheckPredicate, 83,                    // 1299:    check predicate 83
  OPC_CheckField, 8, 13, 0,                  // 1301:    check Inst[20:8] == 0x0
  OPC_Decode, 133, 14, 188, 1,               // 1305:    decode to GINVI using decoder 188
                                             // 1305:   }
  2, 0,                                      // 1310:   case 0x2: {
  OPC_CheckPredicate, 83,                    // 1312:    check predicate 83
  OPC_CheckField, 10, 11, 0,                 // 1314:    check Inst[20:10] == 0x0
  OPC_Decode, 135, 14, 248, 2,               // 1318:    decode to GINVT using decoder 376
                                             // 1318:   }
                                             // 1318:   } // switch Inst[7:6]
                                             // 1318:  }
                                             // 1318:  } // switch Inst[5:0]
                                             // 1318: }
  50, 7,                                     // 1323: case 0x32: {
  OPC_CheckPredicate, 76,                    // 1325:  check predicate 76
  OPC_Decode, 161, 7, 249, 2,                // 1327:  decode to BC using decoder 377
                                             // 1327: }
  53, 20,                                    // 1332: case 0x35: {
  OPC_Scope, 11,                             // 1334:  try {
  OPC_CheckField, 16, 5, 0,                  // 1336:   check Inst[20:16] == 0x0
  OPC_CheckPredicate, 3,                     // 1340:   check predicate 3
  OPC_Decode, 226, 7, 182, 1,                // 1342:   decode to BGTZC_MMR6 using decoder 182
                                             // 1342:  } else try {
  OPC_CheckPredicate, 3,                     // 1347:   check predicate 3
  OPC_Decode, 146, 8, 182, 1,                // 1349:   decode to BLTZC_MMR6 using decoder 182
                                             // 1349:  }
                                             // 1349: }
  54, 19,                                    // 1354: case 0x36: {
  OPC_Scope, 10,                             // 1356:  try {
  OPC_CheckField, 21, 5, 0,                  // 1358:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 75,                    // 1362:   check predicate 75
  OPC_Decode, 200, 14, 110,                  // 1364:   decode to JIC using decoder 110
                                             // 1364:  } else try {
  OPC_CheckPredicate, 76,                    // 1368:   check predicate 76
  OPC_Decode, 195, 7, 250, 2,                // 1370:   decode to BEQZC using decoder 378
                                             // 1370:  }
                                             // 1370: }
  58, 7,                                     // 1375: case 0x3a: {
  OPC_CheckPredicate, 75,                    // 1377:  check predicate 75
  OPC_Decode, 153, 7, 249, 2,                // 1379:  decode to BALC using decoder 377
                                             // 1379: }
  59, 67,                                    // 1384: case 0x3b: {
  OPC_SwitchField, 19, 2,                    // 1386:  switch Inst[20:19] {
  0, 7,                                      // 1389:  case 0x0: {
  OPC_CheckPredicate, 75,                    // 1391:   check predicate 75
  OPC_Decode, 147, 6, 176, 1,                // 1393:   decode to ADDIUPC using decoder 176
                                             // 1393:  }
  1, 7,                                      // 1398:  case 0x1: {
  OPC_CheckPredicate, 75,                    // 1400:   check predicate 75
  OPC_Decode, 192, 15, 176, 1,               // 1402:   decode to LWPC using decoder 176
                                             // 1402:  }
  2, 7,                                      // 1407:  case 0x2: {
  OPC_CheckPredicate, 84,                    // 1409:   check predicate 84
  OPC_Decode, 201, 15, 176, 1,               // 1411:   decode to LWUPC using decoder 176
                                             // 1411:  }
  3, 0,                                      // 1416:  case 0x3: {
  OPC_SwitchField, 18, 1,                    // 1418:   switch Inst[18] {
  0, 7,                                      // 1421:   case 0x0: {
  OPC_CheckPredicate, 84,                    // 1423:    check predicate 84
  OPC_Decode, 252, 14, 251, 2,               // 1425:    decode to LDPC using decoder 379
                                             // 1425:   }
  1, 0,                                      // 1430:   case 0x1: {
  OPC_SwitchField, 16, 2,                    // 1432:    switch Inst[17:16] {
  2, 7,                                      // 1435:    case 0x2: {
  OPC_CheckPredicate, 75,                    // 1437:     check predicate 75
  OPC_Decode, 250, 6, 177, 1,                // 1439:     decode to AUIPC using decoder 177
                                             // 1439:    }
  3, 0,                                      // 1444:    case 0x3: {
  OPC_CheckPredicate, 75,                    // 1446:     check predicate 75
  OPC_Decode, 223, 6, 177, 1,                // 1448:     decode to ALUIPC using decoder 177
                                             // 1448:    }
                                             // 1448:    } // switch Inst[17:16]
                                             // 1448:   }
                                             // 1448:   } // switch Inst[18]
                                             // 1448:  }
                                             // 1448:  } // switch Inst[20:19]
                                             // 1448: }
  61, 20,                                    // 1453: case 0x3d: {
  OPC_Scope, 11,                             // 1455:  try {
  OPC_CheckField, 16, 5, 0,                  // 1457:   check Inst[20:16] == 0x0
  OPC_CheckPredicate, 3,                     // 1461:   check predicate 3
  OPC_Decode, 255, 7, 184, 1,                // 1463:   decode to BLEZC_MMR6 using decoder 184
                                             // 1463:  } else try {
  OPC_CheckPredicate, 3,                     // 1468:   check predicate 3
  OPC_Decode, 217, 7, 184, 1,                // 1470:   decode to BGEZC_MMR6 using decoder 184
                                             // 1470:  }
                                             // 1470: }
  62, 0,                                     // 1475: case 0x3e: {
  OPC_Scope, 10,                             // 1477:  try {
  OPC_CheckField, 21, 5, 0,                  // 1479:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 75,                    // 1483:   check predicate 75
  OPC_Decode, 197, 14, 110,                  // 1485:   decode to JIALC using decoder 110
                                             // 1485:  } else try {
  OPC_CheckPredicate, 76,                    // 1489:   check predicate 76
  OPC_Decode, 170, 8, 250, 2,                // 1491:   decode to BNEZC using decoder 378
                                             // 1491:  }
                                             // 1491: }
                                             // 1491: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMips32r6_64r6_Ambiguous32[135] = {
  OPC_SwitchField, 26, 6,                    //   0: switch Inst[31:26] {
  6, 20,                                     //   3: case 0x6: {
  OPC_Scope, 11,                             //   5:  try {
  OPC_CheckField, 21, 5, 0,                  //   7:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 76,                    //  11:   check predicate 76
  OPC_Decode, 251, 7, 226, 2,                //  13:   decode to BLEZALC using decoder 354
                                             //  13:  } else try {
  OPC_CheckPredicate, 76,                    //  18:   check predicate 76
  OPC_Decode, 204, 7, 226, 2,                //  20:   decode to BGEUC using decoder 354
                                             //  20:  }
                                             //  20: }
  7, 20,                                     //  25: case 0x7: {
  OPC_Scope, 11,                             //  27:  try {
  OPC_CheckField, 21, 5, 0,                  //  29:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 76,                    //  33:   check predicate 76
  OPC_Decode, 222, 7, 227, 2,                //  35:   decode to BGTZALC using decoder 355
                                             //  35:  } else try {
  OPC_CheckPredicate, 76,                    //  40:   check predicate 76
  OPC_Decode, 133, 8, 227, 2,                //  42:   decode to BLTUC using decoder 355
                                             //  42:  }
                                             //  42: }
  8, 20,                                     //  47: case 0x8: {
  OPC_Scope, 11,                             //  49:  try {
  OPC_CheckField, 21, 5, 0,                  //  51:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 76,                    //  55:   check predicate 76
  OPC_Decode, 193, 7, 241, 2,                //  57:   decode to BEQZALC using decoder 369
                                             //  57:  } else try {
  OPC_CheckPredicate, 76,                    //  62:   check predicate 76
  OPC_Decode, 183, 8, 228, 2,                //  64:   decode to BOVC using decoder 356
                                             //  64:  }
                                             //  64: }
  22, 20,                                    //  69: case 0x16: {
  OPC_Scope, 11,                             //  71:  try {
  OPC_CheckField, 21, 5, 0,                  //  73:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 76,                    //  77:   check predicate 76
  OPC_Decode, 253, 7, 239, 2,                //  79:   decode to BLEZC using decoder 367
                                             //  79:  } else try {
  OPC_CheckPredicate, 76,                    //  84:   check predicate 76
  OPC_Decode, 201, 7, 239, 2,                //  86:   decode to BGEC using decoder 367
                                             //  86:  }
                                             //  86: }
  23, 20,                                    //  91: case 0x17: {
  OPC_Scope, 11,                             //  93:  try {
  OPC_CheckField, 21, 5, 0,                  //  95:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 76,                    //  99:   check predicate 76
  OPC_Decode, 224, 7, 240, 2,                // 101:   decode to BGTZC using decoder 368
                                             // 101:  } else try {
  OPC_CheckPredicate, 76,                    // 106:   check predicate 76
  OPC_Decode, 130, 8, 240, 2,                // 108:   decode to BLTC using decoder 368
                                             // 108:  }
                                             // 108: }
  24, 0,                                     // 113: case 0x18: {
  OPC_Scope, 11,                             // 115:  try {
  OPC_CheckField, 21, 5, 0,                  // 117:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 76,                    // 121:   check predicate 76
  OPC_Decode, 168, 8, 241, 2,                // 123:   decode to BNEZALC using decoder 369
                                             // 123:  } else try {
  OPC_CheckPredicate, 76,                    // 128:   check predicate 76
  OPC_Decode, 176, 8, 241, 2,                // 130:   decode to BNVC using decoder 369
                                             // 130:  }
                                             // 130: }
                                             // 130: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMips32r6_64r6_BranchZero32[21] = {
  OPC_SwitchField, 26, 6,                    //  0: switch Inst[31:26] {
  22, 7,                                     //  3: case 0x16: {
  OPC_CheckPredicate, 85,                    //  5:  check predicate 85
  OPC_Decode, 216, 7, 239, 2,                //  7:  decode to BGEZC64 using decoder 367
                                             //  7: }
  23, 0,                                     // 12: case 0x17: {
  OPC_CheckPredicate, 85,                    // 14:  check predicate 85
  OPC_Decode, 145, 8, 240, 2,                // 16:  decode to BLTZC64 using decoder 368
                                             // 16: }
                                             // 16: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMips32r6_64r6_GP6432[159] = {
  OPC_SwitchField, 26, 6,                    //   0: switch Inst[31:26] {
  0, 32,                                     //   3: case 0x0: {
  OPC_SwitchField, 0, 11,                    //   5:  switch Inst[10:0] {
  53, 6,                                     //   8:  case 0x35: {
  OPC_CheckPredicate, 86,                    //  10:   check predicate 86
  OPC_Decode, 225, 19, 50,                   //  12:   decode to SELEQZ64 using decoder 50
                                             //  12:  }
  55, 6,                                     //  16:  case 0x37: {
  OPC_CheckPredicate, 86,                    //  18:   check predicate 86
  OPC_Decode, 232, 19, 50,                   //  20:   decode to SELNEZ64 using decoder 50
                                             //  20:  }
  137, 8, 0,                                 //  24:  case 0x409: {
  OPC_CheckPredicate, 75,                    //  27:   check predicate 75
  OPC_CheckField, 11, 10, 0,                 //  29:   check Inst[20:11] == 0x0
  OPC_Decode, 212, 14, 51,                   //  33:   decode to JR_HB64_R6 using decoder 51
                                             //  33:  }
                                             //  33:  } // switch Inst[10:0]
                                             //  33: }
  6, 7,                                      //  37: case 0x6: {
  OPC_CheckPredicate, 85,                    //  39:  check predicate 85
  OPC_Decode, 205, 7, 226, 2,                //  41:  decode to BGEUC64 using decoder 354
                                             //  41: }
  7, 7,                                      //  46: case 0x7: {
  OPC_CheckPredicate, 85,                    //  48:  check predicate 85
  OPC_Decode, 134, 8, 227, 2,                //  50:  decode to BLTUC64 using decoder 355
                                             //  50: }
  8, 7,                                      //  55: case 0x8: {
  OPC_CheckPredicate, 85,                    //  57:  check predicate 85
  OPC_Decode, 189, 7, 228, 2,                //  59:  decode to BEQC64 using decoder 356
                                             //  59: }
  22, 20,                                    //  64: case 0x16: {
  OPC_Scope, 11,                             //  66:  try {
  OPC_CheckField, 21, 5, 0,                  //  68:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 85,                    //  72:   check predicate 85
  OPC_Decode, 254, 7, 239, 2,                //  74:   decode to BLEZC64 using decoder 367
                                             //  74:  } else try {
  OPC_CheckPredicate, 85,                    //  79:   check predicate 85
  OPC_Decode, 202, 7, 239, 2,                //  81:   decode to BGEC64 using decoder 367
                                             //  81:  }
                                             //  81: }
  23, 20,                                    //  86: case 0x17: {
  OPC_Scope, 11,                             //  88:  try {
  OPC_CheckField, 21, 5, 0,                  //  90:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 85,                    //  94:   check predicate 85
  OPC_Decode, 225, 7, 240, 2,                //  96:   decode to BGTZC64 using decoder 368
                                             //  96:  } else try {
  OPC_CheckPredicate, 85,                    // 101:   check predicate 85
  OPC_Decode, 131, 8, 240, 2,                // 103:   decode to BLTC64 using decoder 368
                                             // 103:  }
                                             // 103: }
  24, 7,                                     // 108: case 0x18: {
  OPC_CheckPredicate, 85,                    // 110:  check predicate 85
  OPC_Decode, 156, 8, 241, 2,                // 112:  decode to BNEC64 using decoder 369
                                             // 112: }
  54, 19,                                    // 117: case 0x36: {
  OPC_Scope, 10,                             // 119:  try {
  OPC_CheckField, 21, 5, 0,                  // 121:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 85,                    // 125:   check predicate 85
  OPC_Decode, 201, 14, 49,                   // 127:   decode to JIC64 using decoder 49
                                             // 127:  } else try {
  OPC_CheckPredicate, 85,                    // 131:   check predicate 85
  OPC_Decode, 197, 7, 252, 2,                // 133:   decode to BEQZC64 using decoder 380
                                             // 133:  }
                                             // 133: }
  62, 0,                                     // 138: case 0x3e: {
  OPC_Scope, 10,                             // 140:  try {
  OPC_CheckField, 21, 5, 0,                  // 142:   check Inst[25:21] == 0x0
  OPC_CheckPredicate, 85,                    // 146:   check predicate 85
  OPC_Decode, 198, 14, 49,                   // 148:   decode to JIALC64 using decoder 49
                                             // 148:  } else try {
  OPC_CheckPredicate, 85,                    // 152:   check predicate 85
  OPC_Decode, 172, 8, 252, 2,                // 154:   decode to BNEZC64 using decoder 380
                                             // 154:  }
                                             // 154: }
                                             // 154: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMips32r6_64r6_PTR6432[29] = {
  OPC_SwitchField, 0, 6,                     //  0: switch Inst[5:0] {
  38, 11,                                    //  3: case 0x26: {
  OPC_CheckPredicate, 87,                    //  5:  check predicate 87
  OPC_CheckField, 26, 6, 31,                 //  7:  check Inst[31:26] == 0x1f
  OPC_Decode, 188, 19, 247, 2,               // 11:  decode to SC64_R6 using decoder 375
                                             // 11: }
  54, 0,                                     // 16: case 0x36: {
  OPC_CheckPredicate, 87,                    // 18:  check predicate 87
  OPC_CheckField, 26, 6, 31,                 // 20:  check Inst[31:26] == 0x1f
  OPC_Decode, 152, 15, 247, 2,               // 24:  decode to LL64_R6 using decoder 375
                                             // 24: }
                                             // 24: } // switch Inst[5:0]
};
static const uint8_t DecoderTableMips6432[778] = {
  OPC_SwitchField, 26, 6,                    //   0: switch Inst[31:26] {
  0, 163, 2,                                 //   3: case 0x0: {
  OPC_SwitchField, 0, 6,                     //   6:  switch Inst[5:0] {
  8, 10,                                     //   9:  case 0x8: {
  OPC_CheckPredicate, 88,                    //  11:   check predicate 88
  OPC_CheckField, 6, 15, 16,                 //  13:   check Inst[20:6] == 0x10
  OPC_Decode, 211, 14, 51,                   //  17:   decode to JR_HB64 using decoder 51
                                             //  17:  }
  9, 27,                                     //  21:  case 0x9: {
  OPC_SwitchField, 6, 5,                     //  23:   switch Inst[10:6] {
  0, 10,                                     //  26:   case 0x0: {
  OPC_CheckPredicate, 89,                    //  28:    check predicate 89
  OPC_CheckField, 16, 5, 0,                  //  30:    check Inst[20:16] == 0x0
  OPC_Decode, 184, 14, 53,                   //  34:    decode to JALR64 using decoder 53
                                             //  34:   }
  16, 0,                                     //  38:   case 0x10: {
  OPC_CheckPredicate, 90,                    //  40:    check predicate 90
  OPC_CheckField, 16, 5, 0,                  //  42:    check Inst[20:16] == 0x0
  OPC_Decode, 191, 14, 53,                   //  46:    decode to JALR_HB64 using decoder 53
                                             //  46:   }
                                             //  46:   } // switch Inst[10:6]
                                             //  46:  }
  20, 11,                                    //  50:  case 0x14: {
  OPC_CheckPredicate, 91,                    //  52:   check predicate 91
  OPC_CheckField, 6, 5, 0,                   //  54:   check Inst[10:6] == 0x0
  OPC_Decode, 149, 12, 253, 2,               //  58:   decode to DSLLV using decoder 381
                                             //  58:  }
  22, 21,                                    //  63:  case 0x16: {
  OPC_SwitchField, 6, 5,                     //  65:   switch Inst[10:6] {
  0, 7,                                      //  68:   case 0x0: {
  OPC_CheckPredicate, 91,                    //  70:    check predicate 91
  OPC_Decode, 155, 12, 253, 2,               //  72:    decode to DSRLV using decoder 381
                                             //  72:   }
  1, 0,                                      //  77:   case 0x1: {
  OPC_CheckPredicate, 90,                    //  79:    check predicate 90
  OPC_Decode, 142, 12, 253, 2,               //  81:    decode to DROTRV using decoder 381
                                             //  81:   }
                                             //  81:   } // switch Inst[10:6]
                                             //  81:  }
  23, 11,                                    //  86:  case 0x17: {
  OPC_CheckPredicate, 91,                    //  88:   check predicate 91
  OPC_CheckField, 6, 5, 0,                   //  90:   check Inst[10:6] == 0x0
  OPC_Decode, 152, 12, 253, 2,               //  94:   decode to DSRAV using decoder 381
                                             //  94:  }
  28, 11,                                    //  99:  case 0x1c: {
  OPC_CheckPredicate, 92,                    // 101:   check predicate 92
  OPC_CheckField, 6, 10, 0,                  // 103:   check Inst[15:6] == 0x0
  OPC_Decode, 213, 11, 254, 2,               // 107:   decode to DMULT using decoder 382
                                             // 107:  }
  29, 11,                                    // 112:  case 0x1d: {
  OPC_CheckPredicate, 92,                    // 114:   check predicate 92
  OPC_CheckField, 6, 10, 0,                  // 116:   check Inst[15:6] == 0x0
  OPC_Decode, 214, 11, 254, 2,               // 120:   decode to DMULTu using decoder 382
                                             // 120:  }
  30, 11,                                    // 125:  case 0x1e: {
  OPC_CheckPredicate, 92,                    // 127:   check predicate 92
  OPC_CheckField, 6, 10, 0,                  // 129:   check Inst[15:6] == 0x0
  OPC_Decode, 144, 12, 254, 2,               // 133:   decode to DSDIV using decoder 382
                                             // 133:  }
  31, 11,                                    // 138:  case 0x1f: {
  OPC_CheckPredicate, 92,                    // 140:   check predicate 92
  OPC_CheckField, 6, 10, 0,                  // 142:   check Inst[15:6] == 0x0
  OPC_Decode, 158, 12, 254, 2,               // 146:   decode to DUDIV using decoder 382
                                             // 146:  }
  44, 10,                                    // 151:  case 0x2c: {
  OPC_CheckPredicate, 91,                    // 153:   check predicate 91
  OPC_CheckField, 6, 5, 0,                   // 155:   check Inst[10:6] == 0x0
  OPC_Decode, 155, 11, 50,                   // 159:   decode to DADD using decoder 50
                                             // 159:  }
  45, 10,                                    // 163:  case 0x2d: {
  OPC_CheckPredicate, 91,                    // 165:   check predicate 91
  OPC_CheckField, 6, 5, 0,                   // 167:   check Inst[10:6] == 0x0
  OPC_Decode, 158, 11, 50,                   // 171:   decode to DADDu using decoder 50
                                             // 171:  }
  46, 10,                                    // 175:  case 0x2e: {
  OPC_CheckPredicate, 91,                    // 177:   check predicate 91
  OPC_CheckField, 6, 5, 0,                   // 179:   check Inst[10:6] == 0x0
  OPC_Decode, 156, 12, 50,                   // 183:   decode to DSUB using decoder 50
                                             // 183:  }
  47, 10,                                    // 187:  case 0x2f: {
  OPC_CheckPredicate, 91,                    // 189:   check predicate 91
  OPC_CheckField, 6, 5, 0,                   // 191:   check Inst[10:6] == 0x0
  OPC_Decode, 157, 12, 50,                   // 195:   decode to DSUBu using decoder 50
                                             // 195:  }
  56, 11,                                    // 199:  case 0x38: {
  OPC_CheckPredicate, 91,                    // 201:   check predicate 91
  OPC_CheckField, 21, 5, 0,                  // 203:   check Inst[25:21] == 0x0
  OPC_Decode, 146, 12, 255, 2,               // 207:   decode to DSLL using decoder 383
                                             // 207:  }
  58, 21,                                    // 212:  case 0x3a: {
  OPC_SwitchField, 21, 5,                    // 214:   switch Inst[25:21] {
  0, 7,                                      // 217:   case 0x0: {
  OPC_CheckPredicate, 91,                    // 219:    check predicate 91
  OPC_Decode, 153, 12, 255, 2,               // 221:    decode to DSRL using decoder 383
                                             // 221:   }
  1, 0,                                      // 226:   case 0x1: {
  OPC_CheckPredicate, 90,                    // 228:    check predicate 90
  OPC_Decode, 140, 12, 255, 2,               // 230:    decode to DROTR using decoder 383
                                             // 230:   }
                                             // 230:   } // switch Inst[25:21]
                                             // 230:  }
  59, 11,                                    // 235:  case 0x3b: {
  OPC_CheckPredicate, 91,                    // 237:   check predicate 91
  OPC_CheckField, 21, 5, 0,                  // 239:   check Inst[25:21] == 0x0
  OPC_Decode, 150, 12, 255, 2,               // 243:   decode to DSRA using decoder 383
                                             // 243:  }
  60, 11,                                    // 248:  case 0x3c: {
  OPC_CheckPredicate, 91,                    // 250:   check predicate 91
  OPC_CheckField, 21, 5, 0,                  // 252:   check Inst[25:21] == 0x0
  OPC_Decode, 147, 12, 255, 2,               // 256:   decode to DSLL32 using decoder 383
                                             // 256:  }
  62, 21,                                    // 261:  case 0x3e: {
  OPC_SwitchField, 21, 5,                    // 263:   switch Inst[25:21] {
  0, 7,                                      // 266:   case 0x0: {
  OPC_CheckPredicate, 91,                    // 268:    check predicate 91
  OPC_Decode, 154, 12, 255, 2,               // 270:    decode to DSRL32 using decoder 383
                                             // 270:   }
  1, 0,                                      // 275:   case 0x1: {
  OPC_CheckPredicate, 90,                    // 277:    check predicate 90
  OPC_Decode, 141, 12, 255, 2,               // 279:    decode to DROTR32 using decoder 383
                                             // 279:   }
                                             // 279:   } // switch Inst[25:21]
                                             // 279:  }
  63, 0,                                     // 284:  case 0x3f: {
  OPC_CheckPredicate, 91,                    // 286:   check predicate 91
  OPC_CheckField, 21, 5, 0,                  // 288:   check Inst[25:21] == 0x0
  OPC_Decode, 151, 12, 255, 2,               // 292:   decode to DSRA32 using decoder 383
                                             // 292:  }
                                             // 292:  } // switch Inst[5:0]
                                             // 292: }
  16, 52,                                    // 297: case 0x10: {
  OPC_SwitchField, 3, 8,                     // 299:  switch Inst[10:3] {
  0, 21,                                     // 302:  case 0x0: {
  OPC_SwitchField, 21, 5,                    // 304:   switch Inst[25:21] {
  1, 7,                                      // 307:   case 0x1: {
  OPC_CheckPredicate, 93,                    // 309:    check predicate 93
  OPC_Decode, 197, 11, 128, 3,               // 311:    decode to DMFC0 using decoder 384
                                             // 311:   }
  5, 0,                                      // 316:   case 0x5: {
  OPC_CheckPredicate, 93,                    // 318:    check predicate 93
  OPC_Decode, 205, 11, 129, 3,               // 320:    decode to DMTC0 using decoder 385
                                             // 320:   }
                                             // 320:   } // switch Inst[25:21]
                                             // 320:  }
  32, 11,                                    // 325:  case 0x20: {
  OPC_CheckPredicate, 94,                    // 327:   check predicate 94
  OPC_CheckField, 21, 5, 3,                  // 329:   check Inst[25:21] == 0x3
  OPC_Decode, 201, 11, 128, 3,               // 333:   decode to DMFGC0 using decoder 384
                                             // 333:  }
  96, 0,                                     // 338:  case 0x60: {
  OPC_CheckPredicate, 94,                    // 340:   check predicate 94
  OPC_CheckField, 21, 5, 3,                  // 342:   check Inst[25:21] == 0x3
  OPC_Decode, 209, 11, 129, 3,               // 346:   decode to DMTGC0 using decoder 385
                                             // 346:  }
                                             // 346:  } // switch Inst[10:3]
                                             // 346: }
  18, 29,                                    // 351: case 0x12: {
  OPC_SwitchField, 21, 5,                    // 353:  switch Inst[25:21] {
  1, 11,                                     // 356:  case 0x1: {
  OPC_CheckPredicate, 93,                    // 358:   check predicate 93
  OPC_CheckField, 3, 8, 0,                   // 360:   check Inst[10:3] == 0x0
  OPC_Decode, 199, 11, 130, 3,               // 364:   decode to DMFC2 using decoder 386
                                             // 364:  }
  5, 0,                                      // 369:  case 0x5: {
  OPC_CheckPredicate, 93,                    // 371:   check predicate 93
  OPC_CheckField, 3, 8, 0,                   // 373:   check Inst[10:3] == 0x0
  OPC_Decode, 207, 11, 131, 3,               // 377:   decode to DMTC2 using decoder 387
                                             // 377:  }
                                             // 377:  } // switch Inst[25:21]
                                             // 377: }
  21, 163, 1,                                // 382: case 0x15: {
  OPC_SwitchField, 0, 13,                    // 385:  switch Inst[12:0] {
  188, 8, 7,                                 // 388:  case 0x43c: {
  OPC_CheckPredicate, 16,                    // 391:   check predicate 16
  OPC_Decode, 193, 10, 132, 3,               // 393:   decode to C_F_D64_MM using decoder 388
                                             // 393:  }
  252, 8, 7,                                 // 398:  case 0x47c: {
  OPC_CheckPredicate, 16,                    // 401:   check predicate 16
  OPC_Decode, 149, 11, 132, 3,               // 403:   decode to C_UN_D64_MM using decoder 388
                                             // 403:  }
  188, 9, 7,                                 // 408:  case 0x4bc: {
  OPC_CheckPredicate, 16,                    // 411:   check predicate 16
  OPC_Decode, 187, 10, 132, 3,               // 413:   decode to C_EQ_D64_MM using decoder 388
                                             // 413:  }
  252, 9, 7,                                 // 418:  case 0x4fc: {
  OPC_CheckPredicate, 16,                    // 421:   check predicate 16
  OPC_Decode, 131, 11, 132, 3,               // 423:   decode to C_UEQ_D64_MM using decoder 388
                                             // 423:  }
  188, 10, 7,                                // 428:  case 0x53c: {
  OPC_CheckPredicate, 16,                    // 431:   check predicate 16
  OPC_Decode, 241, 10, 132, 3,               // 433:   decode to C_OLT_D64_MM using decoder 388
                                             // 433:  }
  252, 10, 7,                                // 438:  case 0x57c: {
  OPC_CheckPredicate, 16,                    // 441:   check predicate 16
  OPC_Decode, 143, 11, 132, 3,               // 443:   decode to C_ULT_D64_MM using decoder 388
                                             // 443:  }
  188, 11, 7,                                // 448:  case 0x5bc: {
  OPC_CheckPredicate, 16,                    // 451:   check predicate 16
  OPC_Decode, 235, 10, 132, 3,               // 453:   decode to C_OLE_D64_MM using decoder 388
                                             // 453:  }
  252, 11, 7,                                // 458:  case 0x5fc: {
  OPC_CheckPredicate, 16,                    // 461:   check predicate 16
  OPC_Decode, 137, 11, 132, 3,               // 463:   decode to C_ULE_D64_MM using decoder 388
                                             // 463:  }
  188, 12, 7,                                // 468:  case 0x63c: {
  OPC_CheckPredicate, 16,                    // 471:   check predicate 16
  OPC_Decode, 253, 10, 132, 3,               // 473:   decode to C_SF_D64_MM using decoder 388
                                             // 473:  }
  252, 12, 7,                                // 478:  case 0x67c: {
  OPC_CheckPredicate, 16,                    // 481:   check predicate 16
  OPC_Decode, 217, 10, 132, 3,               // 483:   decode to C_NGLE_D64_MM using decoder 388
                                             // 483:  }
  188, 13, 7,                                // 488:  case 0x6bc: {
  OPC_CheckPredicate, 16,                    // 491:   check predicate 16
  OPC_Decode, 247, 10, 132, 3,               // 493:   decode to C_SEQ_D64_MM using decoder 388
                                             // 493:  }
  252, 13, 7,                                // 498:  case 0x6fc: {
  OPC_CheckPredicate, 16,                    // 501:   check predicate 16
  OPC_Decode, 223, 10, 132, 3,               // 503:   decode to C_NGL_D64_MM using decoder 388
                                             // 503:  }
  188, 14, 7,                                // 508:  case 0x73c: {
  OPC_CheckPredicate, 16,                    // 511:   check predicate 16
  OPC_Decode, 205, 10, 132, 3,               // 513:   decode to C_LT_D64_MM using decoder 388
                                             // 513:  }
  252, 14, 7,                                // 518:  case 0x77c: {
  OPC_CheckPredicate, 16,                    // 521:   check predicate 16
  OPC_Decode, 211, 10, 132, 3,               // 523:   decode to C_NGE_D64_MM using decoder 388
                                             // 523:  }
  188, 15, 7,                                // 528:  case 0x7bc: {
  OPC_CheckPredicate, 16,                    // 531:   check predicate 16
  OPC_Decode, 199, 10, 132, 3,               // 533:   decode to C_LE_D64_MM using decoder 388
                                             // 533:  }
  252, 15, 0,                                // 538:  case 0x7fc: {
  OPC_CheckPredicate, 16,                    // 541:   check predicate 16
  OPC_Decode, 229, 10, 132, 3,               // 543:   decode to C_NGT_D64_MM using decoder 388
                                             // 543:  }
                                             // 543:  } // switch Inst[12:0]
                                             // 543: }
  24, 7,                                     // 548: case 0x18: {
  OPC_CheckPredicate, 95,                    // 550:  check predicate 95
  OPC_Decode, 156, 11, 133, 3,               // 552:  decode to DADDi using decoder 389
                                             // 552: }
  25, 7,                                     // 557: case 0x19: {
  OPC_CheckPredicate, 91,                    // 559:  check predicate 91
  OPC_Decode, 157, 11, 133, 3,               // 561:  decode to DADDiu using decoder 389
                                             // 561: }
  26, 7,                                     // 566: case 0x1a: {
  OPC_CheckPredicate, 95,                    // 568:  check predicate 95
  OPC_Decode, 251, 14, 148, 1,               // 570:  decode to LDL using decoder 148
                                             // 570: }
  27, 7,                                     // 575: case 0x1b: {
  OPC_CheckPredicate, 95,                    // 577:  check predicate 95
  OPC_Decode, 253, 14, 148, 1,               // 579:  decode to LDR using decoder 148
                                             // 579: }
  28, 21,                                    // 584: case 0x1c: {
  OPC_SwitchField, 0, 11,                    // 586:  switch Inst[10:0] {
  36, 7,                                     // 589:  case 0x24: {
  OPC_CheckPredicate, 96,                    // 591:   check predicate 96
  OPC_Decode, 166, 11, 134, 3,               // 593:   decode to DCLZ using decoder 390
                                             // 593:  }
  37, 0,                                     // 598:  case 0x25: {
  OPC_CheckPredicate, 96,                    // 600:   check predicate 96
  OPC_Decode, 164, 11, 134, 3,               // 602:   decode to DCLO using decoder 390
                                             // 602:  }
                                             // 602:  } // switch Inst[10:0]
                                             // 602: }
  31, 88,                                    // 607: case 0x1f: {
  OPC_SwitchField, 0, 6,                     // 609:  switch Inst[5:0] {
  1, 7,                                      // 612:  case 0x1: {
  OPC_CheckPredicate, 90,                    // 614:   check predicate 90
  OPC_Decode, 175, 11, 135, 3,               // 616:   decode to DEXTM using decoder 391
                                             // 616:  }
  2, 7,                                      // 621:  case 0x2: {
  OPC_CheckPredicate, 90,                    // 623:   check predicate 90
  OPC_Decode, 176, 11, 135, 3,               // 625:   decode to DEXTU using decoder 391
                                             // 625:  }
  3, 7,                                      // 630:  case 0x3: {
  OPC_CheckPredicate, 90,                    // 632:   check predicate 90
  OPC_Decode, 173, 11, 135, 3,               // 634:   decode to DEXT using decoder 391
                                             // 634:  }
  5, 7,                                      // 639:  case 0x5: {
  OPC_CheckPredicate, 90,                    // 641:   check predicate 90
  OPC_Decode, 179, 11, 136, 3,               // 643:   decode to DINSM using decoder 392
                                             // 643:  }
  6, 7,                                      // 648:  case 0x6: {
  OPC_CheckPredicate, 90,                    // 650:   check predicate 90
  OPC_Decode, 180, 11, 136, 3,               // 652:   decode to DINSU using decoder 392
                                             // 652:  }
  7, 7,                                      // 657:  case 0x7: {
  OPC_CheckPredicate, 90,                    // 659:   check predicate 90
  OPC_Decode, 178, 11, 136, 3,               // 661:   decode to DINS using decoder 392
                                             // 661:  }
  36, 0,                                     // 666:  case 0x24: {
  OPC_SwitchField, 6, 5,                     // 668:   switch Inst[10:6] {
  2, 11,                                     // 671:   case 0x2: {
  OPC_CheckPredicate, 90,                    // 673:    check predicate 90
  OPC_CheckField, 21, 5, 0,                  // 675:    check Inst[25:21] == 0x0
  OPC_Decode, 143, 12, 245, 2,               // 679:    decode to DSBH using decoder 373
                                             // 679:   }
  5, 0,                                      // 684:   case 0x5: {
  OPC_CheckPredicate, 90,                    // 686:    check predicate 90
  OPC_CheckField, 21, 5, 0,                  // 688:    check Inst[25:21] == 0x0
  OPC_Decode, 145, 12, 245, 2,               // 692:    decode to DSHD using decoder 373
                                             // 692:   }
                                             // 692:   } // switch Inst[10:6]
                                             // 692:  }
                                             // 692:  } // switch Inst[5:0]
                                             // 692: }
  39, 7,                                     // 697: case 0x27: {
  OPC_CheckPredicate, 91,                    // 699:  check predicate 91
  OPC_Decode, 210, 15, 148, 1,               // 701:  decode to LWu using decoder 148
                                             // 701: }
  44, 7,                                     // 706: case 0x2c: {
  OPC_CheckPredicate, 95,                    // 708:  check predicate 95
  OPC_Decode, 214, 19, 148, 1,               // 710:  decode to SDL using decoder 148
                                             // 710: }
  45, 7,                                     // 715: case 0x2d: {
  OPC_CheckPredicate, 95,                    // 717:  check predicate 95
  OPC_Decode, 215, 19, 148, 1,               // 719:  decode to SDR using decoder 148
                                             // 719: }
  46, 7,                                     // 724: case 0x2e: {
  OPC_CheckPredicate, 21,                    // 726:  check predicate 21
  OPC_Decode, 207, 19, 146, 1,               // 728:  decode to SDC1_MM_D64 using decoder 146
                                             // 728: }
  47, 7,                                     // 733: case 0x2f: {
  OPC_CheckPredicate, 21,                    // 735:  check predicate 21
  OPC_Decode, 242, 14, 146, 1,               // 737:  decode to LDC1_MM_D64 using decoder 146
                                             // 737: }
  52, 7,                                     // 742: case 0x34: {
  OPC_CheckPredicate, 92,                    // 744:  check predicate 92
  OPC_Decode, 153, 15, 148, 1,               // 746:  decode to LLD using decoder 148
                                             // 746: }
  55, 7,                                     // 751: case 0x37: {
  OPC_CheckPredicate, 91,                    // 753:  check predicate 91
  OPC_Decode, 237, 14, 148, 1,               // 755:  decode to LD using decoder 148
                                             // 755: }
  60, 7,                                     // 760: case 0x3c: {
  OPC_CheckPredicate, 95,                    // 762:  check predicate 95
  OPC_Decode, 189, 19, 148, 1,               // 764:  decode to SCD using decoder 148
                                             // 764: }
  63, 0,                                     // 769: case 0x3f: {
  OPC_CheckPredicate, 91,                    // 771:  check predicate 91
  OPC_Decode, 196, 19, 148, 1,               // 773:  decode to SD using decoder 148
                                             // 773: }
                                             // 773: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMipsDSP32[21] = {
  OPC_SwitchField, 26, 6,                    //  0: switch Inst[31:26] {
  35, 7,                                     //  3: case 0x23: {
  OPC_CheckPredicate, 97,                    //  5:  check predicate 97
  OPC_Decode, 179, 15, 148, 1,               //  7:  decode to LWDSP using decoder 148
                                             //  7: }
  43, 0,                                     // 12: case 0x2b: {
  OPC_CheckPredicate, 97,                    // 14:  check predicate 97
  OPC_Decode, 216, 21, 148, 1,               // 16:  decode to SWDSP using decoder 148
                                             // 16: }
                                             // 16: } // switch Inst[31:26]
};
static const uint8_t DecoderTableMipsFP6432[1037] = {
  OPC_SwitchField, 26, 6,                    //    0: switch Inst[31:26] {
  17, 152, 7,                                //    3: case 0x11: {
  OPC_SwitchField, 0, 6,                     //    6:  switch Inst[5:0] {
  0, 73,                                     //    9:  case 0x0: {
  OPC_SwitchField, 21, 5,                    //   11:   switch Inst[25:21] {
  0, 11,                                     //   14:   case 0x0: {
  OPC_CheckPredicate, 98,                    //   16:    check predicate 98
  OPC_CheckField, 6, 5, 0,                   //   18:    check Inst[10:6] == 0x0
  OPC_Decode, 158, 16, 137, 3,               //   22:    decode to MFC1_D64 using decoder 393
                                             //   22:   }
  3, 11,                                     //   27:   case 0x3: {
  OPC_CheckPredicate, 99,                    //   29:    check predicate 99
  OPC_CheckField, 6, 5, 0,                   //   31:    check Inst[10:6] == 0x0
  OPC_Decode, 168, 16, 137, 3,               //   35:    decode to MFHC1_D64 using decoder 393
                                             //   35:   }
  4, 11,                                     //   40:   case 0x4: {
  OPC_CheckPredicate, 98,                    //   42:    check predicate 98
  OPC_CheckField, 6, 5, 0,                   //   44:    check Inst[10:6] == 0x0
  OPC_Decode, 173, 17, 138, 3,               //   48:    decode to MTC1_D64 using decoder 394
                                             //   48:   }
  7, 11,                                     //   53:   case 0x7: {
  OPC_CheckPredicate, 99,                    //   55:    check predicate 99
  OPC_CheckField, 6, 5, 0,                   //   57:    check Inst[10:6] == 0x0
  OPC_Decode, 184, 17, 139, 3,               //   61:    decode to MTHC1_D64 using decoder 395
                                             //   61:   }
  17, 7,                                     //   66:   case 0x11: {
  OPC_CheckPredicate, 98,                    //   68:    check predicate 98
  OPC_Decode, 217, 12, 233, 2,               //   70:    decode to FADD_D64 using decoder 361
                                             //   70:   }
  22, 0,                                     //   75:   case 0x16: {
  OPC_CheckPredicate, 100,                   //   77:    check predicate 100
  OPC_Decode, 219, 12, 233, 2,               //   79:    decode to FADD_PS64 using decoder 361
                                             //   79:   }
                                             //   79:   } // switch Inst[25:21]
                                             //   79:  }
  1, 21,                                     //   84:  case 0x1: {
  OPC_SwitchField, 21, 5,                    //   86:   switch Inst[25:21] {
  17, 7,                                     //   89:   case 0x11: {
  OPC_CheckPredicate, 98,                    //   91:    check predicate 98
  OPC_Decode, 234, 13, 233, 2,               //   93:    decode to FSUB_D64 using decoder 361
                                             //   93:   }
  22, 0,                                     //   98:   case 0x16: {
  OPC_CheckPredicate, 100,                   //  100:    check predicate 100
  OPC_Decode, 236, 13, 233, 2,               //  102:    decode to FSUB_PS64 using decoder 361
                                             //  102:   }
                                             //  102:   } // switch Inst[25:21]
                                             //  102:  }
  2, 21,                                     //  107:  case 0x2: {
  OPC_SwitchField, 21, 5,                    //  109:   switch Inst[25:21] {
  17, 7,                                     //  112:   case 0x11: {
  OPC_CheckPredicate, 98,                    //  114:    check predicate 98
  OPC_Decode, 190, 13, 233, 2,               //  116:    decode to FMUL_D64 using decoder 361
                                             //  116:   }
  22, 0,                                     //  121:   case 0x16: {
  OPC_CheckPredicate, 100,                   //  123:    check predicate 100
  OPC_Decode, 192, 13, 233, 2,               //  125:    decode to FMUL_PS64 using decoder 361
                                             //  125:   }
                                             //  125:   } // switch Inst[25:21]
                                             //  125:  }
  3, 11,                                     //  130:  case 0x3: {
  OPC_CheckPredicate, 98,                    //  132:   check predicate 98
  OPC_CheckField, 21, 5, 17,                 //  134:   check Inst[25:21] == 0x11
  OPC_Decode, 128, 13, 233, 2,               //  138:   decode to FDIV_D64 using decoder 361
                                             //  138:  }
  4, 12,                                     //  143:  case 0x4: {
  OPC_CheckPredicate, 101,                   //  145:   check predicate 101
  OPC_CheckField, 16, 10, 160, 4,            //  147:   check Inst[25:16] == 0x220
  OPC_Decode, 226, 13, 232, 1,               //  152:   decode to FSQRT_D64 using decoder 232
                                             //  152:  }
  5, 12,                                     //  157:  case 0x5: {
  OPC_CheckPredicate, 98,                    //  159:   check predicate 98
  OPC_CheckField, 16, 10, 160, 4,            //  161:   check Inst[25:16] == 0x220
  OPC_Decode, 210, 12, 232, 1,               //  166:   decode to FABS_D64 using decoder 232
                                             //  166:  }
  6, 12,                                     //  171:  case 0x6: {
  OPC_CheckPredicate, 98,                    //  173:   check predicate 98
  OPC_CheckField, 16, 10, 160, 4,            //  175:   check Inst[25:16] == 0x220
  OPC_Decode, 179, 13, 232, 1,               //  180:   decode to FMOV_D64 using decoder 232
                                             //  180:  }
  7, 12,                                     //  185:  case 0x7: {
  OPC_CheckPredicate, 98,                    //  187:   check predicate 98
  OPC_CheckField, 16, 10, 160, 4,            //  189:   check Inst[25:16] == 0x220
  OPC_Decode, 199, 13, 232, 1,               //  194:   decode to FNEG_D64 using decoder 232
                                             //  194:  }
  8, 23,                                     //  199:  case 0x8: {
  OPC_SwitchField, 16, 10,                   //  201:   switch Inst[25:16] {
  128, 4, 7,                                 //  204:   case 0x200: {
  OPC_CheckPredicate, 101,                   //  207:    check predicate 101
  OPC_Decode, 151, 19, 225, 1,               //  209:    decode to ROUND_L_S using decoder 225
                                             //  209:   }
  160, 4, 0,                                 //  214:   case 0x220: {
  OPC_CheckPredicate, 102,                   //  217:    check predicate 102
  OPC_Decode, 149, 19, 232, 1,               //  219:    decode to ROUND_L_D64 using decoder 232
                                             //  219:   }
                                             //  219:   } // switch Inst[25:16]
                                             //  219:  }
  9, 23,                                     //  224:  case 0x9: {
  OPC_SwitchField, 16, 10,                   //  226:   switch Inst[25:16] {
  128, 4, 7,                                 //  229:   case 0x200: {
  OPC_CheckPredicate, 101,                   //  232:    check predicate 101
  OPC_Decode, 190, 22, 225, 1,               //  234:    decode to TRUNC_L_S using decoder 225
                                             //  234:   }
  160, 4, 0,                                 //  239:   case 0x220: {
  OPC_CheckPredicate, 102,                   //  242:    check predicate 102
  OPC_Decode, 188, 22, 232, 1,               //  244:    decode to TRUNC_L_D64 using decoder 232
                                             //  244:   }
                                             //  244:   } // switch Inst[25:16]
                                             //  244:  }
  10, 23,                                    //  249:  case 0xa: {
  OPC_SwitchField, 16, 10,                   //  251:   switch Inst[25:16] {
  128, 4, 7,                                 //  254:   case 0x200: {
  OPC_CheckPredicate, 101,                   //  257:    check predicate 101
  OPC_Decode, 227, 8, 225, 1,                //  259:    decode to CEIL_L_S using decoder 225
                                             //  259:   }
  160, 4, 0,                                 //  264:   case 0x220: {
  OPC_CheckPredicate, 102,                   //  267:    check predicate 102
  OPC_Decode, 225, 8, 232, 1,                //  269:    decode to CEIL_L_D64 using decoder 232
                                             //  269:   }
                                             //  269:   } // switch Inst[25:16]
                                             //  269:  }
  11, 23,                                    //  274:  case 0xb: {
  OPC_SwitchField, 16, 10,                   //  276:   switch Inst[25:16] {
  128, 4, 7,                                 //  279:   case 0x200: {
  OPC_CheckPredicate, 101,                   //  282:    check predicate 101
  OPC_Decode, 158, 13, 225, 1,               //  284:    decode to FLOOR_L_S using decoder 225
                                             //  284:   }
  160, 4, 0,                                 //  289:   case 0x220: {
  OPC_CheckPredicate, 102,                   //  292:    check predicate 102
  OPC_Decode, 156, 13, 232, 1,               //  294:    decode to FLOOR_L_D64 using decoder 232
                                             //  294:   }
                                             //  294:   } // switch Inst[25:16]
                                             //  294:  }
  12, 12,                                    //  299:  case 0xc: {
  OPC_CheckPredicate, 101,                   //  301:   check predicate 101
  OPC_CheckField, 16, 10, 160, 4,            //  303:   check Inst[25:16] == 0x220
  OPC_Decode, 154, 19, 140, 3,               //  308:   decode to ROUND_W_D64 using decoder 396
                                             //  308:  }
  13, 12,                                    //  313:  case 0xd: {
  OPC_CheckPredicate, 101,                   //  315:   check predicate 101
  OPC_CheckField, 16, 10, 160, 4,            //  317:   check Inst[25:16] == 0x220
  OPC_Decode, 193, 22, 140, 3,               //  322:   decode to TRUNC_W_D64 using decoder 396
                                             //  322:  }
  14, 12,                                    //  327:  case 0xe: {
  OPC_CheckPredicate, 101,                   //  329:   check predicate 101
  OPC_CheckField, 16, 10, 160, 4,            //  331:   check Inst[25:16] == 0x220
  OPC_Decode, 230, 8, 140, 3,                //  336:   decode to CEIL_W_D64 using decoder 396
                                             //  336:  }
  15, 12,                                    //  341:  case 0xf: {
  OPC_CheckPredicate, 101,                   //  343:   check predicate 101
  OPC_CheckField, 16, 10, 160, 4,            //  345:   check Inst[25:16] == 0x220
  OPC_Decode, 161, 13, 140, 3,               //  350:   decode to FLOOR_W_D64 using decoder 396
                                             //  350:  }
  17, 29,                                    //  355:  case 0x11: {
  OPC_SwitchField, 16, 2,                    //  357:   switch Inst[17:16] {
  0, 11,                                     //  360:   case 0x0: {
  OPC_CheckPredicate, 103,                   //  362:    check predicate 103
  OPC_CheckField, 21, 5, 17,                 //  364:    check Inst[25:21] == 0x11
  OPC_Decode, 235, 16, 141, 3,               //  368:    decode to MOVF_D64 using decoder 397
                                             //  368:   }
  1, 0,                                      //  373:   case 0x1: {
  OPC_CheckPredicate, 103,                   //  375:    check predicate 103
  OPC_CheckField, 21, 5, 17,                 //  377:    check Inst[25:21] == 0x11
  OPC_Decode, 255, 16, 141, 3,               //  381:    decode to MOVT_D64 using decoder 397
                                             //  381:   }
                                             //  381:   } // switch Inst[17:16]
                                             //  381:  }
  18, 11,                                    //  386:  case 0x12: {
  OPC_CheckPredicate, 103,                   //  388:   check predicate 103
  OPC_CheckField, 21, 5, 17,                 //  390:   check Inst[25:21] == 0x11
  OPC_Decode, 139, 17, 142, 3,               //  394:   decode to MOVZ_I_D64 using decoder 398
                                             //  394:  }
  19, 11,                                    //  399:  case 0x13: {
  OPC_CheckPredicate, 103,                   //  401:   check predicate 103
  OPC_CheckField, 21, 5, 17,                 //  403:   check Inst[25:21] == 0x11
  OPC_Decode, 247, 16, 142, 3,               //  407:   decode to MOVN_I_D64 using decoder 398
                                             //  407:  }
  21, 12,                                    //  412:  case 0x15: {
  OPC_CheckPredicate, 104,                   //  414:   check predicate 104
  OPC_CheckField, 16, 10, 160, 4,            //  416:   check Inst[25:16] == 0x220
  OPC_Decode, 129, 19, 232, 1,               //  421:   decode to RECIP_D64 using decoder 232
                                             //  421:  }
  22, 12,                                    //  426:  case 0x16: {
  OPC_CheckPredicate, 104,                   //  428:   check predicate 104
  OPC_CheckField, 16, 10, 160, 4,            //  430:   check Inst[25:16] == 0x220
  OPC_Decode, 162, 19, 232, 1,               //  435:   decode to RSQRT_D64 using decoder 232
                                             //  435:  }
  24, 11,                                    //  440:  case 0x18: {
  OPC_CheckPredicate, 105,                   //  442:   check predicate 105
  OPC_CheckField, 21, 5, 22,                 //  444:   check Inst[25:21] == 0x16
  OPC_Decode, 169, 6, 233, 2,                //  448:   decode to ADDR_PS64 using decoder 361
                                             //  448:  }
  26, 11,                                    //  453:  case 0x1a: {
  OPC_CheckPredicate, 105,                   //  455:   check predicate 105
  OPC_CheckField, 21, 5, 22,                 //  457:   check Inst[25:21] == 0x16
  OPC_Decode, 229, 17, 233, 2,               //  461:   decode to MULR_PS64 using decoder 361
                                             //  461:  }
  32, 33,                                    //  466:  case 0x20: {
  OPC_SwitchField, 16, 10,                   //  468:   switch Inst[25:16] {
  160, 4, 7,                                 //  471:   case 0x220: {
  OPC_CheckPredicate, 98,                    //  474:    check predicate 98
  OPC_Decode, 168, 10, 140, 3,               //  476:    decode to CVT_S_D64 using decoder 396
                                             //  476:   }
  160, 5, 7,                                 //  481:   case 0x2a0: {
  OPC_CheckPredicate, 106,                   //  484:    check predicate 106
  OPC_Decode, 170, 10, 140, 3,               //  486:    decode to CVT_S_L using decoder 396
                                             //  486:   }
  192, 5, 0,                                 //  491:   case 0x2c0: {
  OPC_CheckPredicate, 100,                   //  494:    check predicate 100
  OPC_Decode, 173, 10, 140, 3,               //  496:    decode to CVT_S_PU64 using decoder 396
                                             //  496:   }
                                             //  496:   } // switch Inst[25:16]
                                             //  496:  }
  33, 33,                                    //  501:  case 0x21: {
  OPC_SwitchField, 16, 10,                   //  503:   switch Inst[25:16] {
  128, 4, 7,                                 //  506:   case 0x200: {
  OPC_CheckPredicate, 98,                    //  509:    check predicate 98
  OPC_Decode, 152, 10, 225, 1,               //  511:    decode to CVT_D64_S using decoder 225
                                             //  511:   }
  128, 5, 7,                                 //  516:   case 0x280: {
  OPC_CheckPredicate, 98,                    //  519:    check predicate 98
  OPC_Decode, 154, 10, 225, 1,               //  521:    decode to CVT_D64_W using decoder 225
                                             //  521:   }
  160, 5, 0,                                 //  526:   case 0x2a0: {
  OPC_CheckPredicate, 106,                   //  529:    check predicate 106
  OPC_Decode, 151, 10, 232, 1,               //  531:    decode to CVT_D64_L using decoder 232
                                             //  531:   }
                                             //  531:   } // switch Inst[25:16]
                                             //  531:  }
  36, 23,                                    //  536:  case 0x24: {
  OPC_SwitchField, 16, 10,                   //  538:   switch Inst[25:16] {
  160, 4, 7,                                 //  541:   case 0x220: {
  OPC_CheckPredicate, 98,                    //  544:    check predicate 98
  OPC_Decode, 179, 10, 140, 3,               //  546:    decode to CVT_W_D64 using decoder 396
                                             //  546:   }
  192, 5, 0,                                 //  551:   case 0x2c0: {
  OPC_CheckPredicate, 105,                   //  554:    check predicate 105
  OPC_Decode, 165, 10, 232, 1,               //  556:    decode to CVT_PW_PS64 using decoder 232
                                             //  556:   }
                                             //  556:   } // switch Inst[25:16]
                                             //  556:  }
  38, 25,                                    //  561:  case 0x26: {
  OPC_SwitchField, 21, 5,                    //  563:   switch Inst[25:21] {
  16, 7,                                     //  566:   case 0x10: {
  OPC_CheckPredicate, 100,                   //  568:    check predicate 100
  OPC_Decode, 164, 10, 143, 3,               //  570:    decode to CVT_PS_S64 using decoder 399
                                             //  570:   }
  20, 0,                                     //  575:   case 0x14: {
  OPC_CheckPredicate, 105,                   //  577:    check predicate 105
  OPC_CheckField, 16, 5, 0,                  //  579:    check Inst[20:16] == 0x0
  OPC_Decode, 163, 10, 232, 1,               //  583:    decode to CVT_PS_PW64 using decoder 232
                                             //  583:   }
                                             //  583:   } // switch Inst[25:21]
                                             //  583:  }
  40, 12,                                    //  588:  case 0x28: {
  OPC_CheckPredicate, 100,                   //  590:   check predicate 100
  OPC_CheckField, 16, 10, 192, 5,            //  592:   check Inst[25:16] == 0x2c0
  OPC_Decode, 172, 10, 140, 3,               //  597:   decode to CVT_S_PL64 using decoder 396
                                             //  597:  }
  44, 11,                                    //  602:  case 0x2c: {
  OPC_CheckPredicate, 100,                   //  604:   check predicate 100
  OPC_CheckField, 21, 5, 22,                 //  606:   check Inst[25:21] == 0x16
  OPC_Decode, 198, 18, 233, 2,               //  610:   decode to PLL_PS64 using decoder 361
                                             //  610:  }
  45, 11,                                    //  615:  case 0x2d: {
  OPC_CheckPredicate, 100,                   //  617:   check predicate 100
  OPC_CheckField, 21, 5, 22,                 //  619:   check Inst[25:21] == 0x16
  OPC_Decode, 199, 18, 233, 2,               //  623:   decode to PLU_PS64 using decoder 361
                                             //  623:  }
  46, 11,                                    //  628:  case 0x2e: {
  OPC_CheckPredicate, 100,                   //  630:   check predicate 100
  OPC_CheckField, 21, 5, 22,                 //  632:   check Inst[25:21] == 0x16
  OPC_Decode, 244, 18, 233, 2,               //  636:   decode to PUL_PS64 using decoder 361
                                             //  636:  }
  47, 11,                                    //  641:  case 0x2f: {
  OPC_CheckPredicate, 100,                   //  643:   check predicate 100
  OPC_CheckField, 21, 5, 22,                 //  645:   check Inst[25:21] == 0x16
  OPC_Decode, 245, 18, 233, 2,               //  649:   decode to PUU_PS64 using decoder 361
                                             //  649:  }
  48, 15,                                    //  654:  case 0x30: {
  OPC_CheckPredicate, 107,                   //  656:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  658:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  662:   check Inst[7:6] == 0x0
  OPC_Decode, 192, 10, 144, 3,               //  666:   decode to C_F_D64 using decoder 400
                                             //  666:  }
  49, 15,                                    //  671:  case 0x31: {
  OPC_CheckPredicate, 107,                   //  673:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  675:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  679:   check Inst[7:6] == 0x0
  OPC_Decode, 148, 11, 144, 3,               //  683:   decode to C_UN_D64 using decoder 400
                                             //  683:  }
  50, 15,                                    //  688:  case 0x32: {
  OPC_CheckPredicate, 107,                   //  690:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  692:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  696:   check Inst[7:6] == 0x0
  OPC_Decode, 186, 10, 144, 3,               //  700:   decode to C_EQ_D64 using decoder 400
                                             //  700:  }
  51, 15,                                    //  705:  case 0x33: {
  OPC_CheckPredicate, 107,                   //  707:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  709:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  713:   check Inst[7:6] == 0x0
  OPC_Decode, 130, 11, 144, 3,               //  717:   decode to C_UEQ_D64 using decoder 400
                                             //  717:  }
  52, 15,                                    //  722:  case 0x34: {
  OPC_CheckPredicate, 107,                   //  724:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  726:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  730:   check Inst[7:6] == 0x0
  OPC_Decode, 240, 10, 144, 3,               //  734:   decode to C_OLT_D64 using decoder 400
                                             //  734:  }
  53, 15,                                    //  739:  case 0x35: {
  OPC_CheckPredicate, 107,                   //  741:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  743:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  747:   check Inst[7:6] == 0x0
  OPC_Decode, 142, 11, 144, 3,               //  751:   decode to C_ULT_D64 using decoder 400
                                             //  751:  }
  54, 15,                                    //  756:  case 0x36: {
  OPC_CheckPredicate, 107,                   //  758:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  760:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  764:   check Inst[7:6] == 0x0
  OPC_Decode, 234, 10, 144, 3,               //  768:   decode to C_OLE_D64 using decoder 400
                                             //  768:  }
  55, 15,                                    //  773:  case 0x37: {
  OPC_CheckPredicate, 107,                   //  775:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  777:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  781:   check Inst[7:6] == 0x0
  OPC_Decode, 136, 11, 144, 3,               //  785:   decode to C_ULE_D64 using decoder 400
                                             //  785:  }
  56, 15,                                    //  790:  case 0x38: {
  OPC_CheckPredicate, 107,                   //  792:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  794:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  798:   check Inst[7:6] == 0x0
  OPC_Decode, 252, 10, 144, 3,               //  802:   decode to C_SF_D64 using decoder 400
                                             //  802:  }
  57, 15,                                    //  807:  case 0x39: {
  OPC_CheckPredicate, 107,                   //  809:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  811:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  815:   check Inst[7:6] == 0x0
  OPC_Decode, 216, 10, 144, 3,               //  819:   decode to C_NGLE_D64 using decoder 400
                                             //  819:  }
  58, 15,                                    //  824:  case 0x3a: {
  OPC_CheckPredicate, 107,                   //  826:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  828:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  832:   check Inst[7:6] == 0x0
  OPC_Decode, 246, 10, 144, 3,               //  836:   decode to C_SEQ_D64 using decoder 400
                                             //  836:  }
  59, 15,                                    //  841:  case 0x3b: {
  OPC_CheckPredicate, 107,                   //  843:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  845:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  849:   check Inst[7:6] == 0x0
  OPC_Decode, 222, 10, 144, 3,               //  853:   decode to C_NGL_D64 using decoder 400
                                             //  853:  }
  60, 15,                                    //  858:  case 0x3c: {
  OPC_CheckPredicate, 107,                   //  860:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  862:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  866:   check Inst[7:6] == 0x0
  OPC_Decode, 204, 10, 144, 3,               //  870:   decode to C_LT_D64 using decoder 400
                                             //  870:  }
  61, 15,                                    //  875:  case 0x3d: {
  OPC_CheckPredicate, 107,                   //  877:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  879:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  883:   check Inst[7:6] == 0x0
  OPC_Decode, 210, 10, 144, 3,               //  887:   decode to C_NGE_D64 using decoder 400
                                             //  887:  }
  62, 15,                                    //  892:  case 0x3e: {
  OPC_CheckPredicate, 107,                   //  894:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  896:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  900:   check Inst[7:6] == 0x0
  OPC_Decode, 198, 10, 144, 3,               //  904:   decode to C_LE_D64 using decoder 400
                                             //  904:  }
  63, 0,                                     //  909:  case 0x3f: {
  OPC_CheckPredicate, 107,                   //  911:   check predicate 107
  OPC_CheckField, 21, 5, 17,                 //  913:   check Inst[25:21] == 0x11
  OPC_CheckField, 6, 2, 0,                   //  917:   check Inst[7:6] == 0x0
  OPC_Decode, 228, 10, 144, 3,               //  921:   decode to C_NGT_D64 using decoder 400
                                             //  921:  }
                                             //  921:  } // switch Inst[5:0]
                                             //  921: }
  19, 91,                                    //  926: case 0x13: {
  OPC_SwitchField, 0, 6,                     //  928:  switch Inst[5:0] {
  1, 11,                                     //  931:  case 0x1: {
  OPC_CheckPredicate, 108,                   //  933:   check predicate 108
  OPC_CheckField, 11, 5, 0,                  //  935:   check Inst[15:11] == 0x0
  OPC_Decode, 255, 14, 145, 3,               //  939:   decode to LDXC164 using decoder 401
                                             //  939:  }
  5, 11,                                     //  944:  case 0x5: {
  OPC_CheckPredicate, 109,                   //  946:   check predicate 109
  OPC_CheckField, 11, 5, 0,                  //  948:   check Inst[15:11] == 0x0
  OPC_Decode, 165, 15, 145, 3,               //  952:   decode to LUXC164 using decoder 401
                                             //  952:  }
  9, 11,                                     //  957:  case 0x9: {
  OPC_CheckPredicate, 108,                   //  959:   check predicate 108
  OPC_CheckField, 6, 5, 0,                   //  961:   check Inst[10:6] == 0x0
  OPC_Decode, 217, 19, 146, 3,               //  965:   decode to SDXC164 using decoder 402
                                             //  965:  }
  13, 11,                                    //  970:  case 0xd: {
  OPC_CheckPredicate, 109,                   //  972:   check predicate 109
  OPC_CheckField, 6, 5, 0,                   //  974:   check Inst[10:6] == 0x0
  OPC_Decode, 204, 21, 146, 3,               //  978:   decode to SUXC164 using decoder 402
                                             //  978:  }
  33, 7,                                     //  983:  case 0x21: {
  OPC_CheckPredicate, 110,                   //  985:   check predicate 110
  OPC_Decode, 239, 15, 147, 3,               //  987:   decode to MADD_D64 using decoder 403
                                             //  987:  }
  41, 7,                                     //  992:  case 0x29: {
  OPC_CheckPredicate, 110,                   //  994:   check predicate 110
  OPC_Decode, 162, 17, 147, 3,               //  996:   decode to MSUB_D64 using decoder 403
                                             //  996:  }
  49, 7,                                     // 1001:  case 0x31: {
  OPC_CheckPredicate, 111,                   // 1003:   check predicate 111
  OPC_Decode, 146, 18, 147, 3,               // 1005:   decode to NMADD_D64 using decoder 403
                                             // 1005:  }
  57, 0,                                     // 1010:  case 0x39: {
  OPC_CheckPredicate, 111,                   // 1012:   check predicate 111
  OPC_Decode, 151, 18, 147, 3,               // 1014:   decode to NMSUB_D64 using decoder 403
                                             // 1014:  }
                                             // 1014:  } // switch Inst[5:0]
                                             // 1014: }
  53, 7,                                     // 1019: case 0x35: {
  OPC_CheckPredicate, 101,                   // 1021:  check predicate 101
  OPC_Decode, 239, 14, 222, 2,               // 1023:  decode to LDC164 using decoder 350
                                             // 1023: }
  61, 0,                                     // 1028: case 0x3d: {
  OPC_CheckPredicate, 101,                   // 1030:  check predicate 101
  OPC_Decode, 204, 19, 222, 2,               // 1032:  decode to SDC164 using decoder 350
                                             // 1032: }
                                             // 1032: } // switch Inst[31:26]
};
// Handling 404 cases.
template <typename InsnType>
static DecodeStatus decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
  DecodeComplete = true;
  using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
  TmpType tmp;
  switch (Idx) {
  default: llvm_unreachable("Invalid decoder index!");
  case 0:
    tmp = fieldFromInstruction(insn, 0, 11);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 1:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 8);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 2:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 8);
    if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 3:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 8);
    if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 4:
    tmp = fieldFromInstruction(insn, 0, 8);
    if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 5:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 3, 2) << 3;
    tmp |= fieldFromInstruction(insn, 5, 3);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 6:
    tmp = fieldFromInstruction(insn, 4, 4);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 7:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 8:
    tmp = fieldFromInstruction(insn, 2, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 9:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 10:
    return S;
  case 11:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 12:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 13:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 14:
    tmp = fieldFromInstruction(insn, 7, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 15:
    if (!Check(S, DecodeMemMMImm4(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 16:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 17:
    tmp = fieldFromInstruction(insn, 7, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodePOOL16BEncodedField(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 18:
    tmp = fieldFromInstruction(insn, 7, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeANDI16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 19:
    tmp = fieldFromInstruction(insn, 3, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 20:
    tmp = fieldFromInstruction(insn, 3, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 3, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 21:
    if (!Check(S, DecodeMemMMReglistImm4Lsl2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 22:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 23:
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 24:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 25:
    if (!Check(S, DecodeMemMMSPImm5Lsl2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 26:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 4);
    if (!Check(S, DecodeSImmWithOffsetAndScale<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 27:
    tmp = fieldFromInstruction(insn, 1, 9);
    if (!Check(S, DecodeSimm9SP(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 28:
    if (!Check(S, DecodeMemMMGPImm7Lsl2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 29:
    tmp = fieldFromInstruction(insn, 7, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeAddiur2Simm7(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 30:
    tmp = fieldFromInstruction(insn, 7, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 6);
    if (!Check(S, DecodeUImmWithOffsetAndScale<6, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 31:
    if (!Check(S, DecodeMovePOperands(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 32:
    tmp = fieldFromInstruction(insn, 7, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 7);
    if (!Check(S, DecodeBranchTarget7MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 33:
    tmp = fieldFromInstruction(insn, 0, 10);
    if (!Check(S, DecodeBranchTarget10MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 34:
    tmp = fieldFromInstruction(insn, 7, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 7);
    if (!Check(S, DecodeLi16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 35:
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 7, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 36:
    tmp = fieldFromInstruction(insn, 7, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 37:
    tmp = fieldFromInstruction(insn, 7, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 7, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 38:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 39:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 40:
    tmp = fieldFromInstruction(insn, 6, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 41:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 5);
    tmp |= fieldFromInstruction(insn, 16, 5) << 11;
    tmp |= fieldFromInstruction(insn, 21, 6) << 5;
    if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 42:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 5);
    tmp |= fieldFromInstruction(insn, 16, 5) << 11;
    tmp |= fieldFromInstruction(insn, 21, 6) << 5;
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 43:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 5);
    tmp |= fieldFromInstruction(insn, 16, 5) << 11;
    tmp |= fieldFromInstruction(insn, 21, 6) << 5;
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 44:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 21, 1) << 5;
    tmp |= fieldFromInstruction(insn, 22, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 45:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 5);
    tmp |= fieldFromInstruction(insn, 16, 5) << 11;
    tmp |= fieldFromInstruction(insn, 21, 6) << 5;
    if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 46:
    if (!Check(S, DecodeFIXMEInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 47:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 5);
    tmp |= fieldFromInstruction(insn, 16, 5) << 11;
    tmp |= fieldFromInstruction(insn, 21, 6) << 5;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 48:
    if (!Check(S, DecodeFMem3(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 49:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 50:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 51:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 52:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 53:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 54:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 10);
    if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 55:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 11, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 56:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 57:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 58:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 59:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 60:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 61:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 62:
    tmp = fieldFromInstruction(insn, 16, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 6, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 63:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 64:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 65:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 66:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 67:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 68:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 69:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 70:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 71:
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    if (!Check(S, DecodeSImmWithOffsetAndScale<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 72:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 73:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 74:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 75:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 76:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 77:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 78:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 79:
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeHI32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 80:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 81:
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeLO32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 82:
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 83:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 14, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 84:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 85:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 86:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 87:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 88:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 89:
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 90:
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 91:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 92:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 93:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 94:
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 95:
    tmp = fieldFromInstruction(insn, 16, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 96:
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 97:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 98:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 99:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 100:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 101:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 14, 7);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 102:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 14, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 103:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 10);
    if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 104:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 105:
    if (!Check(S, DecodeMemMMImm16(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 106:
    if (!Check(S, DecodeMemMMImm12(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 107:
    if (!Check(S, DecodeCacheOpMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 108:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 109:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 110:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 111:
    if (!Check(S, DecodeSyncI_MM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 112:
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget1SImm16(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 113:
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 114:
    tmp = fieldFromInstruction(insn, 18, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 115:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 116:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 117:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 118:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 119:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 120:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 121:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 122:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 123:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 124:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 125:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 126:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 127:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 128:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 129:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 130:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 131:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 132:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 133:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 134:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 135:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 136:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 137:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 138:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 139:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 140:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 141:
    if (!Check(S, DecodeMemMMImm9(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 142:
    if (!Check(S, DecodePrefeOpMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 143:
    if (!Check(S, DecodeJumpTargetMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 144:
    tmp = fieldFromInstruction(insn, 23, 3);
    if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 23);
    if (!Check(S, DecodeSimm23Lsl2(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 145:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 146:
    if (!Check(S, DecodeFMemMMR2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 147:
    if (!Check(S, DecodeJumpTargetXMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 148:
    if (!Check(S, DecodeMem(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 149:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 150:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 151:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 152:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 153:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 154:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 155:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 9, 2);
    if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 156:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 9, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 157:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 9, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 158:
    tmp = fieldFromInstruction(insn, 6, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 159:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 160:
    if (!Check(S, DecodeLoadByte15(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 161:
    if (!Check(S, DecodeFMemCop2MMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 162:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 163:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 164:
    if (!Check(S, DecodeSynciR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 165:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 166:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 167:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 168:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 169:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 170:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 171:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 172:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 173:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 174:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 175:
    if (!Check(S, DecodePOP35GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 176:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 19);
    if (!Check(S, DecodeSimm19Lsl2(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 177:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 178:
    if (!Check(S, DecodePOP37GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 179:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 21);
    if (!Check(S, DecodeBranchTarget21MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 180:
    tmp = fieldFromInstruction(insn, 0, 26);
    if (!Check(S, DecodeBranchTarget26MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 181:
    if (!Check(S, DecodeBlezGroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 182:
    if (!Check(S, DecodePOP65GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 183:
    if (!Check(S, DecodeBgtzGroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 184:
    if (!Check(S, DecodePOP75GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 185:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 186:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 187:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 2);
    if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 188:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 189:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 190:
    tmp = fieldFromInstruction(insn, 6, 20);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 191:
    tmp = fieldFromInstruction(insn, 6, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 192:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 193:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 194:
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeHI32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 195:
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeLO32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 196:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 2);
    if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 197:
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 198:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 199:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 200:
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 201:
    if (!Check(S, DecodeSyncI(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 202:
    if (!Check(S, DecodeJumpTarget(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 203:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 204:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 205:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 206:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 207:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 208:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 4, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 209:
    tmp = fieldFromInstruction(insn, 11, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 210:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 211:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 212:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 213:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 214:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 215:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 216:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 217:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 218:
    tmp = fieldFromInstruction(insn, 18, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 219:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 220:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 221:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 222:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 223:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 224:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 225:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 226:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 227:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 228:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 229:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 230:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 231:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 232:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 233:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 234:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 235:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 236:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 237:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 238:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 239:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 240:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 241:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 242:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 243:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 244:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 245:
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 246:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 11, 5);
    tmp |= fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 247:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 248:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 249:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 250:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 251:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 252:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 253:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 254:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 255:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 256:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 257:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 258:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 259:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 260:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 261:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 262:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 263:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 264:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 265:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 266:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 267:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 268:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 269:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 270:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 271:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 272:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 273:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 274:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 275:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 276:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 277:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 278:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 279:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 280:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 281:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 282:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 283:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 284:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 285:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 286:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 287:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 288:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 289:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 290:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 291:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 292:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSACtrlRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 293:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 294:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 295:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 296:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 297:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSACtrlRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 298:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 299:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 300:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 301:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 302:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 303:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 304:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 305:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 306:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 307:
    if (!Check(S, DecodeINSVE_DF(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 308:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 309:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 310:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 311:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 312:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 313:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 314:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 315:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 316:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 317:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 318:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 319:
    if (!Check(S, DecodeMSA128Mem(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 320:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 321:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 322:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 323:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 324:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 325:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 326:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 327:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 328:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 329:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 330:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 331:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 332:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 333:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 334:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 335:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 336:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 337:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 338:
    if (!Check(S, DecodeMemEVA(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 339:
    if (!Check(S, DecodeCacheeOp_CacheOpR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 340:
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 341:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 342:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 343:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 344:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 345:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 346:
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 6);
    if (!Check(S, DecodeSImmWithOffsetAndScale<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 347:
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 2);
    if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 348:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 349:
    if (!Check(S, DecodeCacheOp(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 350:
    if (!Check(S, DecodeFMem(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 351:
    if (!Check(S, DecodeFMem2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 352:
    if (!Check(S, DecodeDAHIDATI(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 353:
    tmp = fieldFromInstruction(insn, 0, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 354:
    if (!Check(S, DecodeBlezGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 355:
    if (!Check(S, DecodeBgtzGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 356:
    if (!Check(S, DecodeAddiGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 357:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 358:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 359:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 360:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 361:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 362:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 363:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 364:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 365:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 366:
    if (!Check(S, DecodeFMemCop2R6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 367:
    if (!Check(S, DecodeBlezlGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 368:
    if (!Check(S, DecodeBgtzlGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 369:
    if (!Check(S, DecodeDaddiGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 370:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 371:
    if (!Check(S, DecodeCRC(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 372:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 373:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 374:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 375:
    if (!Check(S, DecodeSpecial3LlSc(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 376:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 377:
    tmp = fieldFromInstruction(insn, 0, 26);
    if (!Check(S, DecodeBranchTarget26(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 378:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 21);
    if (!Check(S, DecodeBranchTarget21(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 379:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 18);
    if (!Check(S, DecodeSimm18Lsl3(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 380:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 21);
    if (!Check(S, DecodeBranchTarget21(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 381:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 382:
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 383:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 384:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 385:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 386:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 387:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 388:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 389:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 390:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 11, 5);
    tmp |= fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 391:
    if (!Check(S, DecodeDEXT(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 392:
    if (!Check(S, DecodeDINS(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 393:
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 394:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 395:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 396:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 397:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 398:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 399:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 400:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 401:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 402:
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 403:
    tmp = fieldFromInstruction(insn, 6, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  }
}
static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) {
  switch (Idx) {
  default: llvm_unreachable("Invalid index!");
  case 0:
    return FB[Mips::FeatureMips16];
  case 1:
    return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureMips32r6];
  case 2:
    return FB[Mips::FeatureMicroMips];
  case 3:
    return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6];
  case 4:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureCnMips] && !FB[Mips::FeatureMicroMips];
  case 5:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureCnMips] && !FB[Mips::FeatureMicroMips];
  case 6:
    return FB[Mips::FeatureCnMips];
  case 7:
    return FB[Mips::FeatureMips64] && FB[Mips::FeatureCnMips] && !FB[Mips::FeatureMicroMips];
  case 8:
    return FB[Mips::FeatureCnMipsP];
  case 9:
    return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSP];
  case 10:
    return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSPR2];
  case 11:
    return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r5] && FB[Mips::FeatureVirt];
  case 12:
    return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSPR3];
  case 13:
    return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureMips32r6] && FB[Mips::FeatureDSP];
  case 14:
    return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat];
  case 15:
    return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureNoMadd4];
  case 16:
    return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat];
  case 17:
    return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureNoMadd4];
  case 18:
    return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat];
  case 19:
    return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureSoftFloat];
  case 20:
    return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureSoftFloat];
  case 21:
    return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureSoftFloat];
  case 22:
    return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureEVA];
  case 23:
    return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureMips32r6] && FB[Mips::FeatureEVA];
  case 24:
    return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat];
  case 25:
    return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureGINV];
  case 26:
    return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat];
  case 27:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureMicroMips];
  case 28:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureMicroMips];
  case 29:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 30:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMSA];
  case 31:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 32:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6];
  case 33:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureUseIndirectJumpsHazard];
  case 34:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32];
  case 35:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 36:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureMicroMips];
  case 37:
    return FB[Mips::FeatureDSP];
  case 38:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMSA] && FB[Mips::FeatureMips64];
  case 39:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 40:
    return FB[Mips::FeatureDSP] && !FB[Mips::FeatureMicroMips];
  case 41:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r5] && FB[Mips::FeatureVirt] && !FB[Mips::FeatureMicroMips];
  case 42:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMT] && !FB[Mips::FeatureMicroMips];
  case 43:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3_32] && !FB[Mips::FeatureMicroMips];
  case 44:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r2] && FB[Mips::FeatureEVA] && !FB[Mips::FeatureMicroMips];
  case 45:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r5] && !FB[Mips::FeatureMicroMips];
  case 46:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32] && !FB[Mips::FeatureMicroMips];
  case 47:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 48:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 49:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 50:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 51:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 52:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 53:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureSoftFloat];
  case 54:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 55:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 56:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3_32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 57:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 58:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 59:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 60:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 61:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat];
  case 62:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 63:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips5_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 64:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureNoMadd4];
  case 65:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureNoMadd4];
  case 66:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureNoMadd4] && !FB[Mips::FeatureMicroMips];
  case 67:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureNoMadd4] && !FB[Mips::FeatureMicroMips];
  case 68:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 69:
    return FB[Mips::FeatureDSPR2];
  case 70:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && FB[Mips::FeatureEVA] && !FB[Mips::FeatureMicroMips];
  case 71:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3_32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 72:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 73:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeaturePTR64Bit] && !FB[Mips::FeatureMicroMips];
  case 74:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 75:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r6];
  case 76:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMicroMips];
  case 77:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 78:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMicroMips];
  case 79:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 80:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureCRC] && !FB[Mips::FeatureMicroMips];
  case 81:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64r6] && FB[Mips::FeatureCRC] && !FB[Mips::FeatureMicroMips];
  case 82:
    return !FB[Mips::FeatureMips16] && !FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMicroMips];
  case 83:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureGINV] && !FB[Mips::FeatureMicroMips];
  case 84:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64r6];
  case 85:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips64r6];
  case 86:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips32r6];
  case 87:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 88:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 89:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeaturePTR64Bit];
  case 90:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64r2] && !FB[Mips::FeatureMicroMips];
  case 91:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3] && !FB[Mips::FeatureMicroMips];
  case 92:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 93:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips3];
  case 94:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64r5] && FB[Mips::FeatureVirt];
  case 95:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6];
  case 96:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips64] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
  case 97:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureDSP];
  case 98:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 99:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 100:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 101:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 102:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips3_32] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 103:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 104:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 105:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && FB[Mips::FeatureMips3D];
  case 106:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips3_32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 107:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 108:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat];
  case 109:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips5_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
  case 110:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureNoMadd4];
  case 111:
    return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureNoMadd4] && !FB[Mips::FeatureMicroMips];
  }
}


template <typename InsnType>
static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
                                      InsnType insn, uint64_t Address,
                                      const MCDisassembler *DisAsm,
                                      const MCSubtargetInfo &STI) {
  const FeatureBitset &Bits = STI.getFeatureBits();
  const uint8_t *Ptr = DecodeTable;

  SmallVector<const uint8_t *, 8> ScopeStack;
  DecodeStatus S = MCDisassembler::Success;
  while (true) {
    ptrdiff_t Loc = Ptr - DecodeTable;
    const uint8_t DecoderOp = *Ptr++;
    switch (DecoderOp) {
    default:
      errs() << Loc << ": Unexpected decode table opcode: "
             << (int)DecoderOp << '\n';
      return MCDisassembler::Fail;
    case OPC_Scope: {
      unsigned NumToSkip = decodeULEB128AndIncUnsafe(Ptr);
      const uint8_t *SkipTo = Ptr + NumToSkip;
      ScopeStack.push_back(SkipTo);
      LLVM_DEBUG(dbgs() << Loc << ": OPC_Scope(" << SkipTo - DecodeTable
                        << ")\n");
      continue;
    }
    case OPC_SwitchField: {
      // Decode the start value.
      unsigned Start = decodeULEB128AndIncUnsafe(Ptr);
      unsigned Len = *Ptr++;
      uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
      uint64_t CaseValue;
      unsigned CaseSize;
      while (true) {
        CaseValue = decodeULEB128AndIncUnsafe(Ptr);
        CaseSize = decodeULEB128AndIncUnsafe(Ptr);
        if (FieldValue == CaseValue || !CaseSize)
          break;
        Ptr += CaseSize;
      }
      if (FieldValue == CaseValue) {
        LLVM_DEBUG(dbgs() << Loc << ": OPC_SwitchField(" << Start << ", " << Len
                          << "): " << FieldValue << '\n');
        continue;
      }
      break;
    }
    case OPC_CheckField: {
      // Decode the start value.
      unsigned Start = decodeULEB128AndIncUnsafe(Ptr);
      unsigned Len = *Ptr;
      uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
      // Decode the field value.
      unsigned PtrLen = 0;
      uint64_t ExpectedValue = decodeULEB128(++Ptr, &PtrLen);
      Ptr += PtrLen;
      bool Failed = ExpectedValue != FieldValue;

      LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckField(" << Start << ", " << Len
                        << ", " << ExpectedValue << "): FieldValue = "
                        << FieldValue << ", ExpectedValue = " << ExpectedValue
                        << ": " << (Failed ? "FAIL, " : "PASS\n"););
      if (!Failed)
        continue;
      break;
    }
    case OPC_CheckPredicate: {
      // Decode the Predicate Index value.
      unsigned PIdx = decodeULEB128AndIncUnsafe(Ptr);
      // Check the predicate.
      bool Failed = !checkDecoderPredicate(PIdx, Bits);

      LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckPredicate(" << PIdx << "): "
                        << (Failed ? "FAIL, " : "PASS\n"););
      if (!Failed)
        continue;
      break;
    }
    case OPC_Decode: {
      // Decode the Opcode value.
      unsigned Opc = decodeULEB128AndIncUnsafe(Ptr);
      unsigned DecodeIdx = decodeULEB128AndIncUnsafe(Ptr);

      MI.clear();
      MI.setOpcode(Opc);
      bool DecodeComplete;
      S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm,
                         DecodeComplete);
      LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc
                        << ", using decoder " << DecodeIdx << ": "
                        << (S ? "PASS, " : "FAIL, "));

      if (DecodeComplete) {
        LLVM_DEBUG(dbgs() << "decoding complete\n");
        return S;
      }
      assert(S == MCDisassembler::Fail);
      // Reset decode status. This also drops a SoftFail status that could be
      // set before the decode attempt.
      S = MCDisassembler::Success;
      break;
    }
    }
    if (ScopeStack.empty()) {
      LLVM_DEBUG(dbgs() << "returning Fail\n");
      return MCDisassembler::Fail;
    }
    Ptr = ScopeStack.pop_back_val();
    LLVM_DEBUG(dbgs() << "continuing at " << Ptr - DecodeTable << '\n');
  }
  llvm_unreachable("bogosity detected in disassembler state machine!");
}


} // namespace
