/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|*  * MSP430 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;

static const uint8_t DecoderTable16[222] = {
  OPC_SwitchField, 13, 3,                    //   0: switch Inst[15:13] {
  0, 200, 1,                                 //   3: case 0x0: {
  OPC_SwitchField, 6, 7,                     //   6:  switch Inst[12:6] {
  64, 21,                                    //   9:  case 0x40: {
  OPC_SwitchField, 4, 2,                     //  11:   switch Inst[5:4] {
  0, 4,                                      //  14:   case 0x0: {
  OPC_Decode, 185, 4, 0,                     //  16:    decode to RRC16r using decoder 0
                                             //  16:   }
  2, 4,                                      //  20:   case 0x2: {
  OPC_Decode, 183, 4, 1,                     //  22:    decode to RRC16n using decoder 1
                                             //  22:   }
  3, 0,                                      //  26:   case 0x3: {
  OPC_Decode, 184, 4, 1,                     //  28:    decode to RRC16p using decoder 1
                                             //  28:   }
                                             //  28:   } // switch Inst[5:4]
                                             //  28:  }
  65, 21,                                    //  32:  case 0x41: {
  OPC_SwitchField, 4, 2,                     //  34:   switch Inst[5:4] {
  0, 4,                                      //  37:   case 0x0: {
  OPC_Decode, 189, 4, 2,                     //  39:    decode to RRC8r using decoder 2
                                             //  39:   }
  2, 4,                                      //  43:   case 0x2: {
  OPC_Decode, 187, 4, 1,                     //  45:    decode to RRC8n using decoder 1
                                             //  45:   }
  3, 0,                                      //  49:   case 0x3: {
  OPC_Decode, 188, 4, 1,                     //  51:    decode to RRC8p using decoder 1
                                             //  51:   }
                                             //  51:   } // switch Inst[5:4]
                                             //  51:  }
  66, 21,                                    //  55:  case 0x42: {
  OPC_SwitchField, 4, 2,                     //  57:   switch Inst[5:4] {
  0, 4,                                      //  60:   case 0x0: {
  OPC_Decode, 247, 4, 0,                     //  62:    decode to SWPB16r using decoder 0
                                             //  62:   }
  2, 4,                                      //  66:   case 0x2: {
  OPC_Decode, 245, 4, 1,                     //  68:    decode to SWPB16n using decoder 1
                                             //  68:   }
  3, 0,                                      //  72:   case 0x3: {
  OPC_Decode, 246, 4, 1,                     //  74:    decode to SWPB16p using decoder 1
                                             //  74:   }
                                             //  74:   } // switch Inst[5:4]
                                             //  74:  }
  68, 21,                                    //  78:  case 0x44: {
  OPC_SwitchField, 4, 2,                     //  80:   switch Inst[5:4] {
  0, 4,                                      //  83:   case 0x0: {
  OPC_Decode, 177, 4, 0,                     //  85:    decode to RRA16r using decoder 0
                                             //  85:   }
  2, 4,                                      //  89:   case 0x2: {
  OPC_Decode, 175, 4, 1,                     //  91:    decode to RRA16n using decoder 1
                                             //  91:   }
  3, 0,                                      //  95:   case 0x3: {
  OPC_Decode, 176, 4, 1,                     //  97:    decode to RRA16p using decoder 1
                                             //  97:   }
                                             //  97:   } // switch Inst[5:4]
                                             //  97:  }
  69, 21,                                    // 101:  case 0x45: {
  OPC_SwitchField, 4, 2,                     // 103:   switch Inst[5:4] {
  0, 4,                                      // 106:   case 0x0: {
  OPC_Decode, 181, 4, 2,                     // 108:    decode to RRA8r using decoder 2
                                             // 108:   }
  2, 4,                                      // 112:   case 0x2: {
  OPC_Decode, 179, 4, 1,                     // 114:    decode to RRA8n using decoder 1
                                             // 114:   }
  3, 0,                                      // 118:   case 0x3: {
  OPC_Decode, 180, 4, 1,                     // 120:    decode to RRA8p using decoder 1
                                             // 120:   }
                                             // 120:   } // switch Inst[5:4]
                                             // 120:  }
  70, 21,                                    // 124:  case 0x46: {
  OPC_SwitchField, 4, 2,                     // 126:   switch Inst[5:4] {
  0, 4,                                      // 129:   case 0x0: {
  OPC_Decode, 195, 4, 0,                     // 131:    decode to SEXT16r using decoder 0
                                             // 131:   }
  2, 4,                                      // 135:   case 0x2: {
  OPC_Decode, 193, 4, 1,                     // 137:    decode to SEXT16n using decoder 1
                                             // 137:   }
  3, 0,                                      // 141:   case 0x3: {
  OPC_Decode, 194, 4, 1,                     // 143:    decode to SEXT16p using decoder 1
                                             // 143:   }
                                             // 143:   } // switch Inst[5:4]
                                             // 143:  }
  72, 14,                                    // 147:  case 0x48: {
  OPC_Scope, 8,                              // 149:   try {
  OPC_CheckField, 4, 2, 0,                   // 151:    check Inst[5:4] == 0x0
  OPC_Decode, 170, 4, 1,                     // 155:    decode to PUSH16r using decoder 1
                                             // 155:   } else try {
  OPC_Decode, 168, 4, 3,                     // 159:    decode to PUSH16c using decoder 3
                                             // 159:   }
                                             // 159:  }
  73, 8,                                     // 163:  case 0x49: {
  OPC_CheckField, 4, 2, 0,                   // 165:   check Inst[5:4] == 0x0
  OPC_Decode, 171, 4, 4,                     // 169:   decode to PUSH8r using decoder 4
                                             // 169:  }
  74, 21,                                    // 173:  case 0x4a: {
  OPC_SwitchField, 4, 2,                     // 175:   switch Inst[5:4] {
  0, 4,                                      // 178:   case 0x0: {
  OPC_Decode, 220, 3, 1,                     // 180:    decode to CALLr using decoder 1
                                             // 180:   }
  2, 4,                                      // 184:   case 0x2: {
  OPC_Decode, 218, 3, 1,                     // 186:    decode to CALLn using decoder 1
                                             // 186:   }
  3, 0,                                      // 190:   case 0x3: {
  OPC_Decode, 219, 3, 1,                     // 192:    decode to CALLp using decoder 1
                                             // 192:   }
                                             // 192:   } // switch Inst[5:4]
                                             // 192:  }
  76, 0,                                     // 196:  case 0x4c: {
  OPC_CheckField, 0, 6, 0,                   // 198:   check Inst[5:0] == 0x0
  OPC_Decode, 173, 4, 5,                     // 202:   decode to RETI using decoder 5
                                             // 202:  }
                                             // 202:  } // switch Inst[12:6]
                                             // 202: }
  1, 0,                                      // 206: case 0x1: {
  OPC_Scope, 8,                              // 208:  try {
  OPC_CheckField, 10, 3, 7,                  // 210:   check Inst[12:10] == 0x7
  OPC_Decode, 142, 4, 6,                     // 214:   decode to JMP using decoder 6
                                             // 214:  } else try {
  OPC_Decode, 141, 4, 7,                     // 218:   decode to JCC using decoder 7
                                             // 218:  }
                                             // 218: }
                                             // 218: } // switch Inst[15:13]
};
static const uint8_t DecoderTableAlpha16[217] = {
  OPC_SwitchField, 12, 4,                    //   0: switch Inst[15:12] {
  4, 25,                                     //   3: case 0x4: {
  OPC_SwitchField, 4, 4,                     //   5:  switch Inst[7:4] {
  0, 14,                                     //   8:  case 0x0: {
  OPC_Scope, 8,                              //  10:   try {
  OPC_CheckField, 0, 4, 0,                   //  12:    check Inst[3:0] == 0x0
  OPC_Decode, 215, 3, 8,                     //  16:    decode to Br using decoder 8
                                             //  16:   } else try {
  OPC_Decode, 153, 4, 9,                     //  20:    decode to MOV16rr using decoder 9
                                             //  20:   }
                                             //  20:  }
  4, 0,                                      //  24:  case 0x4: {
  OPC_Decode, 164, 4, 10,                    //  26:   decode to MOV8rr using decoder 10
                                             //  26:  }
                                             //  26:  } // switch Inst[7:4]
                                             //  26: }
  5, 15,                                     //  30: case 0x5: {
  OPC_SwitchField, 4, 4,                     //  32:  switch Inst[7:4] {
  0, 4,                                      //  35:  case 0x0: {
  OPC_Decode, 205, 2, 11,                    //  37:   decode to ADD16rr using decoder 11
                                             //  37:  }
  4, 0,                                      //  41:  case 0x4: {
  OPC_Decode, 217, 2, 12,                    //  43:   decode to ADD8rr using decoder 12
                                             //  43:  }
                                             //  43:  } // switch Inst[7:4]
                                             //  43: }
  6, 15,                                     //  47: case 0x6: {
  OPC_SwitchField, 4, 4,                     //  49:  switch Inst[7:4] {
  0, 4,                                      //  52:  case 0x0: {
  OPC_Decode, 229, 2, 11,                    //  54:   decode to ADDC16rr using decoder 11
                                             //  54:  }
  4, 0,                                      //  58:  case 0x4: {
  OPC_Decode, 241, 2, 12,                    //  60:   decode to ADDC8rr using decoder 12
                                             //  60:  }
                                             //  60:  } // switch Inst[7:4]
                                             //  60: }
  7, 15,                                     //  64: case 0x7: {
  OPC_SwitchField, 4, 4,                     //  66:  switch Inst[7:4] {
  0, 4,                                      //  69:  case 0x0: {
  OPC_Decode, 231, 4, 11,                    //  71:   decode to SUBC16rr using decoder 11
                                             //  71:  }
  4, 0,                                      //  75:  case 0x4: {
  OPC_Decode, 243, 4, 12,                    //  77:   decode to SUBC8rr using decoder 12
                                             //  77:  }
                                             //  77:  } // switch Inst[7:4]
                                             //  77: }
  8, 15,                                     //  81: case 0x8: {
  OPC_SwitchField, 4, 4,                     //  83:  switch Inst[7:4] {
  0, 4,                                      //  86:  case 0x0: {
  OPC_Decode, 207, 4, 11,                    //  88:   decode to SUB16rr using decoder 11
                                             //  88:  }
  4, 0,                                      //  92:  case 0x4: {
  OPC_Decode, 219, 4, 12,                    //  94:   decode to SUB8rr using decoder 12
                                             //  94:  }
                                             //  94:  } // switch Inst[7:4]
                                             //  94: }
  9, 15,                                     //  98: case 0x9: {
  OPC_SwitchField, 4, 4,                     // 100:  switch Inst[7:4] {
  0, 4,                                      // 103:  case 0x0: {
  OPC_Decode, 232, 3, 9,                     // 105:   decode to CMP16rr using decoder 9
                                             // 105:  }
  4, 0,                                      // 109:  case 0x4: {
  OPC_Decode, 244, 3, 10,                    // 111:   decode to CMP8rr using decoder 10
                                             // 111:  }
                                             // 111:  } // switch Inst[7:4]
                                             // 111: }
  10, 15,                                    // 115: case 0xa: {
  OPC_SwitchField, 4, 4,                     // 117:  switch Inst[7:4] {
  0, 4,                                      // 120:  case 0x0: {
  OPC_Decode, 128, 4, 11,                    // 122:   decode to DADD16rr using decoder 11
                                             // 122:  }
  4, 0,                                      // 126:  case 0x4: {
  OPC_Decode, 140, 4, 12,                    // 128:   decode to DADD8rr using decoder 12
                                             // 128:  }
                                             // 128:  } // switch Inst[7:4]
                                             // 128: }
  11, 15,                                    // 132: case 0xb: {
  OPC_SwitchField, 4, 4,                     // 134:  switch Inst[7:4] {
  0, 4,                                      // 137:  case 0x0: {
  OPC_Decode, 200, 3, 9,                     // 139:   decode to BIT16rr using decoder 9
                                             // 139:  }
  4, 0,                                      // 143:  case 0x4: {
  OPC_Decode, 212, 3, 10,                    // 145:   decode to BIT8rr using decoder 10
                                             // 145:  }
                                             // 145:  } // switch Inst[7:4]
                                             // 145: }
  12, 15,                                    // 149: case 0xc: {
  OPC_SwitchField, 4, 4,                     // 151:  switch Inst[7:4] {
  0, 4,                                      // 154:  case 0x0: {
  OPC_Decode, 152, 3, 11,                    // 156:   decode to BIC16rr using decoder 11
                                             // 156:  }
  4, 0,                                      // 160:  case 0x4: {
  OPC_Decode, 164, 3, 12,                    // 162:   decode to BIC8rr using decoder 12
                                             // 162:  }
                                             // 162:  } // switch Inst[7:4]
                                             // 162: }
  13, 15,                                    // 166: case 0xd: {
  OPC_SwitchField, 4, 4,                     // 168:  switch Inst[7:4] {
  0, 4,                                      // 171:  case 0x0: {
  OPC_Decode, 176, 3, 11,                    // 173:   decode to BIS16rr using decoder 11
                                             // 173:  }
  4, 0,                                      // 177:  case 0x4: {
  OPC_Decode, 188, 3, 12,                    // 179:   decode to BIS8rr using decoder 12
                                             // 179:  }
                                             // 179:  } // switch Inst[7:4]
                                             // 179: }
  14, 15,                                    // 183: case 0xe: {
  OPC_SwitchField, 4, 4,                     // 185:  switch Inst[7:4] {
  0, 4,                                      // 188:  case 0x0: {
  OPC_Decode, 139, 5, 11,                    // 190:   decode to XOR16rr using decoder 11
                                             // 190:  }
  4, 0,                                      // 194:  case 0x4: {
  OPC_Decode, 151, 5, 12,                    // 196:   decode to XOR8rr using decoder 12
                                             // 196:  }
                                             // 196:  } // switch Inst[7:4]
                                             // 196: }
  15, 0,                                     // 200: case 0xf: {
  OPC_SwitchField, 4, 4,                     // 202:  switch Inst[7:4] {
  0, 4,                                      // 205:  case 0x0: {
  OPC_Decode, 128, 3, 11,                    // 207:   decode to AND16rr using decoder 11
                                             // 207:  }
  4, 0,                                      // 211:  case 0x4: {
  OPC_Decode, 140, 3, 12,                    // 213:   decode to AND8rr using decoder 12
                                             // 213:  }
                                             // 213:  } // switch Inst[7:4]
                                             // 213: }
                                             // 213: } // switch Inst[15:12]
};
static const uint8_t DecoderTableBeta16[207] = {
  OPC_SwitchField, 12, 4,                    //   0: switch Inst[15:12] {
  4, 15,                                     //   3: case 0x4: {
  OPC_SwitchField, 6, 2,                     //   5:  switch Inst[7:6] {
  0, 4,                                      //   8:  case 0x0: {
  OPC_Decode, 148, 4, 13,                    //  10:   decode to MOV16rc using decoder 13
                                             //  10:  }
  1, 0,                                      //  14:  case 0x1: {
  OPC_Decode, 159, 4, 14,                    //  16:   decode to MOV8rc using decoder 14
                                             //  16:  }
                                             //  16:  } // switch Inst[7:6]
                                             //  16: }
  5, 15,                                     //  20: case 0x5: {
  OPC_SwitchField, 6, 2,                     //  22:  switch Inst[7:6] {
  0, 4,                                      //  25:  case 0x0: {
  OPC_Decode, 200, 2, 15,                    //  27:   decode to ADD16rc using decoder 15
                                             //  27:  }
  1, 0,                                      //  31:  case 0x1: {
  OPC_Decode, 212, 2, 16,                    //  33:   decode to ADD8rc using decoder 16
                                             //  33:  }
                                             //  33:  } // switch Inst[7:6]
                                             //  33: }
  6, 15,                                     //  37: case 0x6: {
  OPC_SwitchField, 6, 2,                     //  39:  switch Inst[7:6] {
  0, 4,                                      //  42:  case 0x0: {
  OPC_Decode, 224, 2, 15,                    //  44:   decode to ADDC16rc using decoder 15
                                             //  44:  }
  1, 0,                                      //  48:  case 0x1: {
  OPC_Decode, 236, 2, 16,                    //  50:   decode to ADDC8rc using decoder 16
                                             //  50:  }
                                             //  50:  } // switch Inst[7:6]
                                             //  50: }
  7, 15,                                     //  54: case 0x7: {
  OPC_SwitchField, 6, 2,                     //  56:  switch Inst[7:6] {
  0, 4,                                      //  59:  case 0x0: {
  OPC_Decode, 226, 4, 15,                    //  61:   decode to SUBC16rc using decoder 15
                                             //  61:  }
  1, 0,                                      //  65:  case 0x1: {
  OPC_Decode, 238, 4, 16,                    //  67:   decode to SUBC8rc using decoder 16
                                             //  67:  }
                                             //  67:  } // switch Inst[7:6]
                                             //  67: }
  8, 15,                                     //  71: case 0x8: {
  OPC_SwitchField, 6, 2,                     //  73:  switch Inst[7:6] {
  0, 4,                                      //  76:  case 0x0: {
  OPC_Decode, 202, 4, 15,                    //  78:   decode to SUB16rc using decoder 15
                                             //  78:  }
  1, 0,                                      //  82:  case 0x1: {
  OPC_Decode, 214, 4, 16,                    //  84:   decode to SUB8rc using decoder 16
                                             //  84:  }
                                             //  84:  } // switch Inst[7:6]
                                             //  84: }
  9, 15,                                     //  88: case 0x9: {
  OPC_SwitchField, 6, 2,                     //  90:  switch Inst[7:6] {
  0, 4,                                      //  93:  case 0x0: {
  OPC_Decode, 227, 3, 13,                    //  95:   decode to CMP16rc using decoder 13
                                             //  95:  }
  1, 0,                                      //  99:  case 0x1: {
  OPC_Decode, 239, 3, 14,                    // 101:   decode to CMP8rc using decoder 14
                                             // 101:  }
                                             // 101:  } // switch Inst[7:6]
                                             // 101: }
  10, 15,                                    // 105: case 0xa: {
  OPC_SwitchField, 6, 2,                     // 107:  switch Inst[7:6] {
  0, 4,                                      // 110:  case 0x0: {
  OPC_Decode, 251, 3, 15,                    // 112:   decode to DADD16rc using decoder 15
                                             // 112:  }
  1, 0,                                      // 116:  case 0x1: {
  OPC_Decode, 135, 4, 16,                    // 118:   decode to DADD8rc using decoder 16
                                             // 118:  }
                                             // 118:  } // switch Inst[7:6]
                                             // 118: }
  11, 15,                                    // 122: case 0xb: {
  OPC_SwitchField, 6, 2,                     // 124:  switch Inst[7:6] {
  0, 4,                                      // 127:  case 0x0: {
  OPC_Decode, 195, 3, 13,                    // 129:   decode to BIT16rc using decoder 13
                                             // 129:  }
  1, 0,                                      // 133:  case 0x1: {
  OPC_Decode, 207, 3, 14,                    // 135:   decode to BIT8rc using decoder 14
                                             // 135:  }
                                             // 135:  } // switch Inst[7:6]
                                             // 135: }
  12, 15,                                    // 139: case 0xc: {
  OPC_SwitchField, 6, 2,                     // 141:  switch Inst[7:6] {
  0, 4,                                      // 144:  case 0x0: {
  OPC_Decode, 147, 3, 15,                    // 146:   decode to BIC16rc using decoder 15
                                             // 146:  }
  1, 0,                                      // 150:  case 0x1: {
  OPC_Decode, 159, 3, 16,                    // 152:   decode to BIC8rc using decoder 16
                                             // 152:  }
                                             // 152:  } // switch Inst[7:6]
                                             // 152: }
  13, 15,                                    // 156: case 0xd: {
  OPC_SwitchField, 6, 2,                     // 158:  switch Inst[7:6] {
  0, 4,                                      // 161:  case 0x0: {
  OPC_Decode, 171, 3, 15,                    // 163:   decode to BIS16rc using decoder 15
                                             // 163:  }
  1, 0,                                      // 167:  case 0x1: {
  OPC_Decode, 183, 3, 16,                    // 169:   decode to BIS8rc using decoder 16
                                             // 169:  }
                                             // 169:  } // switch Inst[7:6]
                                             // 169: }
  14, 15,                                    // 173: case 0xe: {
  OPC_SwitchField, 6, 2,                     // 175:  switch Inst[7:6] {
  0, 4,                                      // 178:  case 0x0: {
  OPC_Decode, 134, 5, 15,                    // 180:   decode to XOR16rc using decoder 15
                                             // 180:  }
  1, 0,                                      // 184:  case 0x1: {
  OPC_Decode, 146, 5, 16,                    // 186:   decode to XOR8rc using decoder 16
                                             // 186:  }
                                             // 186:  } // switch Inst[7:6]
                                             // 186: }
  15, 0,                                     // 190: case 0xf: {
  OPC_SwitchField, 6, 2,                     // 192:  switch Inst[7:6] {
  0, 4,                                      // 195:  case 0x0: {
  OPC_Decode, 251, 2, 15,                    // 197:   decode to AND16rc using decoder 15
                                             // 197:  }
  1, 0,                                      // 201:  case 0x1: {
  OPC_Decode, 135, 3, 16,                    // 203:   decode to AND8rc using decoder 16
                                             // 203:  }
                                             // 203:  } // switch Inst[7:6]
                                             // 203: }
                                             // 203: } // switch Inst[15:12]
};
static const uint8_t DecoderTableDelta16[375] = {
  OPC_SwitchField, 12, 4,                    //   0: switch Inst[15:12] {
  4, 51,                                     //   3: case 0x4: {
  OPC_SwitchField, 4, 4,                     //   5:  switch Inst[7:4] {
  2, 4,                                      //   8:  case 0x2: {
  OPC_Decode, 151, 4, 9,                     //  10:   decode to MOV16rn using decoder 9
                                             //  10:  }
  3, 28,                                     //  14:  case 0x3: {
  OPC_Scope, 12,                             //  16:   try {
  OPC_CheckField, 0, 4, 0,                   //  18:    check Inst[3:0] == 0x0
  OPC_CheckField, 8, 4, 1,                   //  22:    check Inst[11:8] == 0x1
  OPC_Decode, 172, 4, 5,                     //  26:    decode to RET using decoder 5
  OPC_Scope, 8,                              //  30:   } else try {
  OPC_CheckField, 8, 4, 1,                   //  32:    check Inst[11:8] == 0x1
  OPC_Decode, 167, 4, 1,                     //  36:    decode to POP16r using decoder 1
                                             //  36:   } else try {
  OPC_Decode, 152, 4, 17,                    //  40:    decode to MOV16rp using decoder 17
                                             //  40:   }
                                             //  40:  }
  6, 4,                                      //  44:  case 0x6: {
  OPC_Decode, 162, 4, 18,                    //  46:   decode to MOV8rn using decoder 18
                                             //  46:  }
  7, 0,                                      //  50:  case 0x7: {
  OPC_Decode, 163, 4, 19,                    //  52:   decode to MOV8rp using decoder 19
                                             //  52:  }
                                             //  52:  } // switch Inst[7:4]
                                             //  52: }
  5, 27,                                     //  56: case 0x5: {
  OPC_SwitchField, 4, 4,                     //  58:  switch Inst[7:4] {
  2, 4,                                      //  61:  case 0x2: {
  OPC_Decode, 203, 2, 11,                    //  63:   decode to ADD16rn using decoder 11
                                             //  63:  }
  3, 4,                                      //  67:  case 0x3: {
  OPC_Decode, 204, 2, 20,                    //  69:   decode to ADD16rp using decoder 20
                                             //  69:  }
  6, 4,                                      //  73:  case 0x6: {
  OPC_Decode, 215, 2, 21,                    //  75:   decode to ADD8rn using decoder 21
                                             //  75:  }
  7, 0,                                      //  79:  case 0x7: {
  OPC_Decode, 216, 2, 22,                    //  81:   decode to ADD8rp using decoder 22
                                             //  81:  }
                                             //  81:  } // switch Inst[7:4]
                                             //  81: }
  6, 27,                                     //  85: case 0x6: {
  OPC_SwitchField, 4, 4,                     //  87:  switch Inst[7:4] {
  2, 4,                                      //  90:  case 0x2: {
  OPC_Decode, 227, 2, 11,                    //  92:   decode to ADDC16rn using decoder 11
                                             //  92:  }
  3, 4,                                      //  96:  case 0x3: {
  OPC_Decode, 228, 2, 20,                    //  98:   decode to ADDC16rp using decoder 20
                                             //  98:  }
  6, 4,                                      // 102:  case 0x6: {
  OPC_Decode, 239, 2, 21,                    // 104:   decode to ADDC8rn using decoder 21
                                             // 104:  }
  7, 0,                                      // 108:  case 0x7: {
  OPC_Decode, 240, 2, 22,                    // 110:   decode to ADDC8rp using decoder 22
                                             // 110:  }
                                             // 110:  } // switch Inst[7:4]
                                             // 110: }
  7, 27,                                     // 114: case 0x7: {
  OPC_SwitchField, 4, 4,                     // 116:  switch Inst[7:4] {
  2, 4,                                      // 119:  case 0x2: {
  OPC_Decode, 229, 4, 11,                    // 121:   decode to SUBC16rn using decoder 11
                                             // 121:  }
  3, 4,                                      // 125:  case 0x3: {
  OPC_Decode, 230, 4, 20,                    // 127:   decode to SUBC16rp using decoder 20
                                             // 127:  }
  6, 4,                                      // 131:  case 0x6: {
  OPC_Decode, 241, 4, 21,                    // 133:   decode to SUBC8rn using decoder 21
                                             // 133:  }
  7, 0,                                      // 137:  case 0x7: {
  OPC_Decode, 242, 4, 22,                    // 139:   decode to SUBC8rp using decoder 22
                                             // 139:  }
                                             // 139:  } // switch Inst[7:4]
                                             // 139: }
  8, 27,                                     // 143: case 0x8: {
  OPC_SwitchField, 4, 4,                     // 145:  switch Inst[7:4] {
  2, 4,                                      // 148:  case 0x2: {
  OPC_Decode, 205, 4, 11,                    // 150:   decode to SUB16rn using decoder 11
                                             // 150:  }
  3, 4,                                      // 154:  case 0x3: {
  OPC_Decode, 206, 4, 20,                    // 156:   decode to SUB16rp using decoder 20
                                             // 156:  }
  6, 4,                                      // 160:  case 0x6: {
  OPC_Decode, 217, 4, 21,                    // 162:   decode to SUB8rn using decoder 21
                                             // 162:  }
  7, 0,                                      // 166:  case 0x7: {
  OPC_Decode, 218, 4, 22,                    // 168:   decode to SUB8rp using decoder 22
                                             // 168:  }
                                             // 168:  } // switch Inst[7:4]
                                             // 168: }
  9, 27,                                     // 172: case 0x9: {
  OPC_SwitchField, 4, 4,                     // 174:  switch Inst[7:4] {
  2, 4,                                      // 177:  case 0x2: {
  OPC_Decode, 230, 3, 9,                     // 179:   decode to CMP16rn using decoder 9
                                             // 179:  }
  3, 4,                                      // 183:  case 0x3: {
  OPC_Decode, 231, 3, 9,                     // 185:   decode to CMP16rp using decoder 9
                                             // 185:  }
  6, 4,                                      // 189:  case 0x6: {
  OPC_Decode, 242, 3, 18,                    // 191:   decode to CMP8rn using decoder 18
                                             // 191:  }
  7, 0,                                      // 195:  case 0x7: {
  OPC_Decode, 243, 3, 18,                    // 197:   decode to CMP8rp using decoder 18
                                             // 197:  }
                                             // 197:  } // switch Inst[7:4]
                                             // 197: }
  10, 27,                                    // 201: case 0xa: {
  OPC_SwitchField, 4, 4,                     // 203:  switch Inst[7:4] {
  2, 4,                                      // 206:  case 0x2: {
  OPC_Decode, 254, 3, 11,                    // 208:   decode to DADD16rn using decoder 11
                                             // 208:  }
  3, 4,                                      // 212:  case 0x3: {
  OPC_Decode, 255, 3, 20,                    // 214:   decode to DADD16rp using decoder 20
                                             // 214:  }
  6, 4,                                      // 218:  case 0x6: {
  OPC_Decode, 138, 4, 21,                    // 220:   decode to DADD8rn using decoder 21
                                             // 220:  }
  7, 0,                                      // 224:  case 0x7: {
  OPC_Decode, 139, 4, 22,                    // 226:   decode to DADD8rp using decoder 22
                                             // 226:  }
                                             // 226:  } // switch Inst[7:4]
                                             // 226: }
  11, 27,                                    // 230: case 0xb: {
  OPC_SwitchField, 4, 4,                     // 232:  switch Inst[7:4] {
  2, 4,                                      // 235:  case 0x2: {
  OPC_Decode, 198, 3, 9,                     // 237:   decode to BIT16rn using decoder 9
                                             // 237:  }
  3, 4,                                      // 241:  case 0x3: {
  OPC_Decode, 199, 3, 9,                     // 243:   decode to BIT16rp using decoder 9
                                             // 243:  }
  6, 4,                                      // 247:  case 0x6: {
  OPC_Decode, 210, 3, 18,                    // 249:   decode to BIT8rn using decoder 18
                                             // 249:  }
  7, 0,                                      // 253:  case 0x7: {
  OPC_Decode, 211, 3, 18,                    // 255:   decode to BIT8rp using decoder 18
                                             // 255:  }
                                             // 255:  } // switch Inst[7:4]
                                             // 255: }
  12, 27,                                    // 259: case 0xc: {
  OPC_SwitchField, 4, 4,                     // 261:  switch Inst[7:4] {
  2, 4,                                      // 264:  case 0x2: {
  OPC_Decode, 150, 3, 11,                    // 266:   decode to BIC16rn using decoder 11
                                             // 266:  }
  3, 4,                                      // 270:  case 0x3: {
  OPC_Decode, 151, 3, 20,                    // 272:   decode to BIC16rp using decoder 20
                                             // 272:  }
  6, 4,                                      // 276:  case 0x6: {
  OPC_Decode, 162, 3, 21,                    // 278:   decode to BIC8rn using decoder 21
                                             // 278:  }
  7, 0,                                      // 282:  case 0x7: {
  OPC_Decode, 163, 3, 22,                    // 284:   decode to BIC8rp using decoder 22
                                             // 284:  }
                                             // 284:  } // switch Inst[7:4]
                                             // 284: }
  13, 27,                                    // 288: case 0xd: {
  OPC_SwitchField, 4, 4,                     // 290:  switch Inst[7:4] {
  2, 4,                                      // 293:  case 0x2: {
  OPC_Decode, 174, 3, 11,                    // 295:   decode to BIS16rn using decoder 11
                                             // 295:  }
  3, 4,                                      // 299:  case 0x3: {
  OPC_Decode, 175, 3, 20,                    // 301:   decode to BIS16rp using decoder 20
                                             // 301:  }
  6, 4,                                      // 305:  case 0x6: {
  OPC_Decode, 186, 3, 21,                    // 307:   decode to BIS8rn using decoder 21
                                             // 307:  }
  7, 0,                                      // 311:  case 0x7: {
  OPC_Decode, 187, 3, 22,                    // 313:   decode to BIS8rp using decoder 22
                                             // 313:  }
                                             // 313:  } // switch Inst[7:4]
                                             // 313: }
  14, 27,                                    // 317: case 0xe: {
  OPC_SwitchField, 4, 4,                     // 319:  switch Inst[7:4] {
  2, 4,                                      // 322:  case 0x2: {
  OPC_Decode, 137, 5, 11,                    // 324:   decode to XOR16rn using decoder 11
                                             // 324:  }
  3, 4,                                      // 328:  case 0x3: {
  OPC_Decode, 138, 5, 20,                    // 330:   decode to XOR16rp using decoder 20
                                             // 330:  }
  6, 4,                                      // 334:  case 0x6: {
  OPC_Decode, 149, 5, 21,                    // 336:   decode to XOR8rn using decoder 21
                                             // 336:  }
  7, 0,                                      // 340:  case 0x7: {
  OPC_Decode, 150, 5, 22,                    // 342:   decode to XOR8rp using decoder 22
                                             // 342:  }
                                             // 342:  } // switch Inst[7:4]
                                             // 342: }
  15, 0,                                     // 346: case 0xf: {
  OPC_SwitchField, 4, 4,                     // 348:  switch Inst[7:4] {
  2, 4,                                      // 351:  case 0x2: {
  OPC_Decode, 254, 2, 11,                    // 353:   decode to AND16rn using decoder 11
                                             // 353:  }
  3, 4,                                      // 357:  case 0x3: {
  OPC_Decode, 255, 2, 20,                    // 359:   decode to AND16rp using decoder 20
                                             // 359:  }
  6, 4,                                      // 363:  case 0x6: {
  OPC_Decode, 138, 3, 21,                    // 365:   decode to AND8rn using decoder 21
                                             // 365:  }
  7, 0,                                      // 369:  case 0x7: {
  OPC_Decode, 139, 3, 22,                    // 371:   decode to AND8rp using decoder 22
                                             // 371:  }
                                             // 371:  } // switch Inst[7:4]
                                             // 371: }
                                             // 371: } // switch Inst[15:12]
};
static const uint8_t DecoderTable32[74] = {
  OPC_SwitchField, 4, 12,                    //  0: switch Inst[15:4] {
  129, 2, 4,                                 //  3: case 0x101: {
  OPC_Decode, 182, 4, 23,                    //  6:  decode to RRC16m using decoder 23
                                             //  6: }
  133, 2, 4,                                 // 10: case 0x105: {
  OPC_Decode, 186, 4, 23,                    // 13:  decode to RRC8m using decoder 23
                                             // 13: }
  137, 2, 4,                                 // 17: case 0x109: {
  OPC_Decode, 244, 4, 23,                    // 20:  decode to SWPB16m using decoder 23
                                             // 20: }
  145, 2, 4,                                 // 24: case 0x111: {
  OPC_Decode, 174, 4, 23,                    // 27:  decode to RRA16m using decoder 23
                                             // 27: }
  149, 2, 4,                                 // 31: case 0x115: {
  OPC_Decode, 178, 4, 23,                    // 34:  decode to RRA8m using decoder 23
                                             // 34: }
  153, 2, 4,                                 // 38: case 0x119: {
  OPC_Decode, 192, 4, 23,                    // 41:  decode to SEXT16m using decoder 23
                                             // 41: }
  163, 2, 8,                                 // 45: case 0x123: {
  OPC_CheckField, 0, 4, 0,                   // 48:  check Inst[3:0] == 0x0
  OPC_Decode, 169, 4, 24,                    // 52:  decode to PUSH16i using decoder 24
                                             // 52: }
  169, 2, 4,                                 // 56: case 0x129: {
  OPC_Decode, 217, 3, 23,                    // 59:  decode to CALLm using decoder 23
                                             // 59: }
  171, 2, 0,                                 // 63: case 0x12b: {
  OPC_CheckField, 0, 4, 0,                   // 66:  check Inst[3:0] == 0x0
  OPC_Decode, 216, 3, 24,                    // 70:  decode to CALLi using decoder 24
                                             // 70: }
                                             // 70: } // switch Inst[15:4]
};
static const uint8_t DecoderTableAlpha32[207] = {
  OPC_SwitchField, 12, 4,                    //   0: switch Inst[15:12] {
  4, 15,                                     //   3: case 0x4: {
  OPC_SwitchField, 4, 4,                     //   5:  switch Inst[7:4] {
  8, 4,                                      //   8:  case 0x8: {
  OPC_Decode, 147, 4, 25,                    //  10:   decode to MOV16mr using decoder 25
                                             //  10:  }
  12, 0,                                     //  14:  case 0xc: {
  OPC_Decode, 158, 4, 26,                    //  16:   decode to MOV8mr using decoder 26
                                             //  16:  }
                                             //  16:  } // switch Inst[7:4]
                                             //  16: }
  5, 15,                                     //  20: case 0x5: {
  OPC_SwitchField, 4, 4,                     //  22:  switch Inst[7:4] {
  8, 4,                                      //  25:  case 0x8: {
  OPC_Decode, 199, 2, 25,                    //  27:   decode to ADD16mr using decoder 25
                                             //  27:  }
  12, 0,                                     //  31:  case 0xc: {
  OPC_Decode, 211, 2, 26,                    //  33:   decode to ADD8mr using decoder 26
                                             //  33:  }
                                             //  33:  } // switch Inst[7:4]
                                             //  33: }
  6, 15,                                     //  37: case 0x6: {
  OPC_SwitchField, 4, 4,                     //  39:  switch Inst[7:4] {
  8, 4,                                      //  42:  case 0x8: {
  OPC_Decode, 223, 2, 25,                    //  44:   decode to ADDC16mr using decoder 25
                                             //  44:  }
  12, 0,                                     //  48:  case 0xc: {
  OPC_Decode, 235, 2, 26,                    //  50:   decode to ADDC8mr using decoder 26
                                             //  50:  }
                                             //  50:  } // switch Inst[7:4]
                                             //  50: }
  7, 15,                                     //  54: case 0x7: {
  OPC_SwitchField, 4, 4,                     //  56:  switch Inst[7:4] {
  8, 4,                                      //  59:  case 0x8: {
  OPC_Decode, 225, 4, 25,                    //  61:   decode to SUBC16mr using decoder 25
                                             //  61:  }
  12, 0,                                     //  65:  case 0xc: {
  OPC_Decode, 237, 4, 26,                    //  67:   decode to SUBC8mr using decoder 26
                                             //  67:  }
                                             //  67:  } // switch Inst[7:4]
                                             //  67: }
  8, 15,                                     //  71: case 0x8: {
  OPC_SwitchField, 4, 4,                     //  73:  switch Inst[7:4] {
  8, 4,                                      //  76:  case 0x8: {
  OPC_Decode, 201, 4, 25,                    //  78:   decode to SUB16mr using decoder 25
                                             //  78:  }
  12, 0,                                     //  82:  case 0xc: {
  OPC_Decode, 213, 4, 26,                    //  84:   decode to SUB8mr using decoder 26
                                             //  84:  }
                                             //  84:  } // switch Inst[7:4]
                                             //  84: }
  9, 15,                                     //  88: case 0x9: {
  OPC_SwitchField, 4, 4,                     //  90:  switch Inst[7:4] {
  8, 4,                                      //  93:  case 0x8: {
  OPC_Decode, 226, 3, 25,                    //  95:   decode to CMP16mr using decoder 25
                                             //  95:  }
  12, 0,                                     //  99:  case 0xc: {
  OPC_Decode, 238, 3, 26,                    // 101:   decode to CMP8mr using decoder 26
                                             // 101:  }
                                             // 101:  } // switch Inst[7:4]
                                             // 101: }
  10, 15,                                    // 105: case 0xa: {
  OPC_SwitchField, 4, 4,                     // 107:  switch Inst[7:4] {
  8, 4,                                      // 110:  case 0x8: {
  OPC_Decode, 250, 3, 25,                    // 112:   decode to DADD16mr using decoder 25
                                             // 112:  }
  12, 0,                                     // 116:  case 0xc: {
  OPC_Decode, 134, 4, 26,                    // 118:   decode to DADD8mr using decoder 26
                                             // 118:  }
                                             // 118:  } // switch Inst[7:4]
                                             // 118: }
  11, 15,                                    // 122: case 0xb: {
  OPC_SwitchField, 4, 4,                     // 124:  switch Inst[7:4] {
  8, 4,                                      // 127:  case 0x8: {
  OPC_Decode, 194, 3, 25,                    // 129:   decode to BIT16mr using decoder 25
                                             // 129:  }
  12, 0,                                     // 133:  case 0xc: {
  OPC_Decode, 206, 3, 26,                    // 135:   decode to BIT8mr using decoder 26
                                             // 135:  }
                                             // 135:  } // switch Inst[7:4]
                                             // 135: }
  12, 15,                                    // 139: case 0xc: {
  OPC_SwitchField, 4, 4,                     // 141:  switch Inst[7:4] {
  8, 4,                                      // 144:  case 0x8: {
  OPC_Decode, 146, 3, 25,                    // 146:   decode to BIC16mr using decoder 25
                                             // 146:  }
  12, 0,                                     // 150:  case 0xc: {
  OPC_Decode, 158, 3, 26,                    // 152:   decode to BIC8mr using decoder 26
                                             // 152:  }
                                             // 152:  } // switch Inst[7:4]
                                             // 152: }
  13, 15,                                    // 156: case 0xd: {
  OPC_SwitchField, 4, 4,                     // 158:  switch Inst[7:4] {
  8, 4,                                      // 161:  case 0x8: {
  OPC_Decode, 170, 3, 25,                    // 163:   decode to BIS16mr using decoder 25
                                             // 163:  }
  12, 0,                                     // 167:  case 0xc: {
  OPC_Decode, 182, 3, 26,                    // 169:   decode to BIS8mr using decoder 26
                                             // 169:  }
                                             // 169:  } // switch Inst[7:4]
                                             // 169: }
  14, 15,                                    // 173: case 0xe: {
  OPC_SwitchField, 4, 4,                     // 175:  switch Inst[7:4] {
  8, 4,                                      // 178:  case 0x8: {
  OPC_Decode, 133, 5, 25,                    // 180:   decode to XOR16mr using decoder 25
                                             // 180:  }
  12, 0,                                     // 184:  case 0xc: {
  OPC_Decode, 145, 5, 26,                    // 186:   decode to XOR8mr using decoder 26
                                             // 186:  }
                                             // 186:  } // switch Inst[7:4]
                                             // 186: }
  15, 0,                                     // 190: case 0xf: {
  OPC_SwitchField, 4, 4,                     // 192:  switch Inst[7:4] {
  8, 4,                                      // 195:  case 0x8: {
  OPC_Decode, 250, 2, 25,                    // 197:   decode to AND16mr using decoder 25
                                             // 197:  }
  12, 0,                                     // 201:  case 0xc: {
  OPC_Decode, 134, 3, 26,                    // 203:   decode to AND8mr using decoder 26
                                             // 203:  }
                                             // 203:  } // switch Inst[7:4]
                                             // 203: }
                                             // 203: } // switch Inst[15:12]
};
static const uint8_t DecoderTableBeta32[207] = {
  OPC_SwitchField, 12, 4,                    //   0: switch Inst[15:12] {
  4, 15,                                     //   3: case 0x4: {
  OPC_SwitchField, 6, 2,                     //   5:  switch Inst[7:6] {
  2, 4,                                      //   8:  case 0x2: {
  OPC_Decode, 143, 4, 27,                    //  10:   decode to MOV16mc using decoder 27
                                             //  10:  }
  3, 0,                                      //  14:  case 0x3: {
  OPC_Decode, 154, 4, 27,                    //  16:   decode to MOV8mc using decoder 27
                                             //  16:  }
                                             //  16:  } // switch Inst[7:6]
                                             //  16: }
  5, 15,                                     //  20: case 0x5: {
  OPC_SwitchField, 6, 2,                     //  22:  switch Inst[7:6] {
  2, 4,                                      //  25:  case 0x2: {
  OPC_Decode, 194, 2, 27,                    //  27:   decode to ADD16mc using decoder 27
                                             //  27:  }
  3, 0,                                      //  31:  case 0x3: {
  OPC_Decode, 206, 2, 27,                    //  33:   decode to ADD8mc using decoder 27
                                             //  33:  }
                                             //  33:  } // switch Inst[7:6]
                                             //  33: }
  6, 15,                                     //  37: case 0x6: {
  OPC_SwitchField, 6, 2,                     //  39:  switch Inst[7:6] {
  2, 4,                                      //  42:  case 0x2: {
  OPC_Decode, 218, 2, 27,                    //  44:   decode to ADDC16mc using decoder 27
                                             //  44:  }
  3, 0,                                      //  48:  case 0x3: {
  OPC_Decode, 230, 2, 27,                    //  50:   decode to ADDC8mc using decoder 27
                                             //  50:  }
                                             //  50:  } // switch Inst[7:6]
                                             //  50: }
  7, 15,                                     //  54: case 0x7: {
  OPC_SwitchField, 6, 2,                     //  56:  switch Inst[7:6] {
  2, 4,                                      //  59:  case 0x2: {
  OPC_Decode, 220, 4, 27,                    //  61:   decode to SUBC16mc using decoder 27
                                             //  61:  }
  3, 0,                                      //  65:  case 0x3: {
  OPC_Decode, 232, 4, 27,                    //  67:   decode to SUBC8mc using decoder 27
                                             //  67:  }
                                             //  67:  } // switch Inst[7:6]
                                             //  67: }
  8, 15,                                     //  71: case 0x8: {
  OPC_SwitchField, 6, 2,                     //  73:  switch Inst[7:6] {
  2, 4,                                      //  76:  case 0x2: {
  OPC_Decode, 196, 4, 27,                    //  78:   decode to SUB16mc using decoder 27
                                             //  78:  }
  3, 0,                                      //  82:  case 0x3: {
  OPC_Decode, 208, 4, 27,                    //  84:   decode to SUB8mc using decoder 27
                                             //  84:  }
                                             //  84:  } // switch Inst[7:6]
                                             //  84: }
  9, 15,                                     //  88: case 0x9: {
  OPC_SwitchField, 6, 2,                     //  90:  switch Inst[7:6] {
  2, 4,                                      //  93:  case 0x2: {
  OPC_Decode, 221, 3, 27,                    //  95:   decode to CMP16mc using decoder 27
                                             //  95:  }
  3, 0,                                      //  99:  case 0x3: {
  OPC_Decode, 233, 3, 27,                    // 101:   decode to CMP8mc using decoder 27
                                             // 101:  }
                                             // 101:  } // switch Inst[7:6]
                                             // 101: }
  10, 15,                                    // 105: case 0xa: {
  OPC_SwitchField, 6, 2,                     // 107:  switch Inst[7:6] {
  2, 4,                                      // 110:  case 0x2: {
  OPC_Decode, 245, 3, 27,                    // 112:   decode to DADD16mc using decoder 27
                                             // 112:  }
  3, 0,                                      // 116:  case 0x3: {
  OPC_Decode, 129, 4, 27,                    // 118:   decode to DADD8mc using decoder 27
                                             // 118:  }
                                             // 118:  } // switch Inst[7:6]
                                             // 118: }
  11, 15,                                    // 122: case 0xb: {
  OPC_SwitchField, 6, 2,                     // 124:  switch Inst[7:6] {
  2, 4,                                      // 127:  case 0x2: {
  OPC_Decode, 189, 3, 27,                    // 129:   decode to BIT16mc using decoder 27
                                             // 129:  }
  3, 0,                                      // 133:  case 0x3: {
  OPC_Decode, 201, 3, 27,                    // 135:   decode to BIT8mc using decoder 27
                                             // 135:  }
                                             // 135:  } // switch Inst[7:6]
                                             // 135: }
  12, 15,                                    // 139: case 0xc: {
  OPC_SwitchField, 6, 2,                     // 141:  switch Inst[7:6] {
  2, 4,                                      // 144:  case 0x2: {
  OPC_Decode, 141, 3, 27,                    // 146:   decode to BIC16mc using decoder 27
                                             // 146:  }
  3, 0,                                      // 150:  case 0x3: {
  OPC_Decode, 153, 3, 27,                    // 152:   decode to BIC8mc using decoder 27
                                             // 152:  }
                                             // 152:  } // switch Inst[7:6]
                                             // 152: }
  13, 15,                                    // 156: case 0xd: {
  OPC_SwitchField, 6, 2,                     // 158:  switch Inst[7:6] {
  2, 4,                                      // 161:  case 0x2: {
  OPC_Decode, 165, 3, 27,                    // 163:   decode to BIS16mc using decoder 27
                                             // 163:  }
  3, 0,                                      // 167:  case 0x3: {
  OPC_Decode, 177, 3, 27,                    // 169:   decode to BIS8mc using decoder 27
                                             // 169:  }
                                             // 169:  } // switch Inst[7:6]
                                             // 169: }
  14, 15,                                    // 173: case 0xe: {
  OPC_SwitchField, 6, 2,                     // 175:  switch Inst[7:6] {
  2, 4,                                      // 178:  case 0x2: {
  OPC_Decode, 128, 5, 27,                    // 180:   decode to XOR16mc using decoder 27
                                             // 180:  }
  3, 0,                                      // 184:  case 0x3: {
  OPC_Decode, 140, 5, 27,                    // 186:   decode to XOR8mc using decoder 27
                                             // 186:  }
                                             // 186:  } // switch Inst[7:6]
                                             // 186: }
  15, 0,                                     // 190: case 0xf: {
  OPC_SwitchField, 6, 2,                     // 192:  switch Inst[7:6] {
  2, 4,                                      // 195:  case 0x2: {
  OPC_Decode, 245, 2, 27,                    // 197:   decode to AND16mc using decoder 27
                                             // 197:  }
  3, 0,                                      // 201:  case 0x3: {
  OPC_Decode, 129, 3, 27,                    // 203:   decode to AND8mc using decoder 27
                                             // 203:  }
                                             // 203:  } // switch Inst[7:6]
                                             // 203: }
                                             // 203: } // switch Inst[15:12]
};
static const uint8_t DecoderTableDelta32[339] = {
  OPC_SwitchField, 12, 4,                    //   0: switch Inst[15:12] {
  4, 15,                                     //   3: case 0x4: {
  OPC_SwitchField, 4, 4,                     //   5:  switch Inst[7:4] {
  10, 4,                                     //   8:  case 0xa: {
  OPC_Decode, 146, 4, 25,                    //  10:   decode to MOV16mn using decoder 25
                                             //  10:  }
  14, 0,                                     //  14:  case 0xe: {
  OPC_Decode, 157, 4, 25,                    //  16:   decode to MOV8mn using decoder 25
                                             //  16:  }
                                             //  16:  } // switch Inst[7:4]
                                             //  16: }
  5, 27,                                     //  20: case 0x5: {
  OPC_SwitchField, 4, 4,                     //  22:  switch Inst[7:4] {
  10, 4,                                     //  25:  case 0xa: {
  OPC_Decode, 197, 2, 25,                    //  27:   decode to ADD16mn using decoder 25
                                             //  27:  }
  11, 4,                                     //  31:  case 0xb: {
  OPC_Decode, 198, 2, 25,                    //  33:   decode to ADD16mp using decoder 25
                                             //  33:  }
  14, 4,                                     //  37:  case 0xe: {
  OPC_Decode, 209, 2, 25,                    //  39:   decode to ADD8mn using decoder 25
                                             //  39:  }
  15, 0,                                     //  43:  case 0xf: {
  OPC_Decode, 210, 2, 25,                    //  45:   decode to ADD8mp using decoder 25
                                             //  45:  }
                                             //  45:  } // switch Inst[7:4]
                                             //  45: }
  6, 27,                                     //  49: case 0x6: {
  OPC_SwitchField, 4, 4,                     //  51:  switch Inst[7:4] {
  10, 4,                                     //  54:  case 0xa: {
  OPC_Decode, 221, 2, 25,                    //  56:   decode to ADDC16mn using decoder 25
                                             //  56:  }
  11, 4,                                     //  60:  case 0xb: {
  OPC_Decode, 222, 2, 25,                    //  62:   decode to ADDC16mp using decoder 25
                                             //  62:  }
  14, 4,                                     //  66:  case 0xe: {
  OPC_Decode, 233, 2, 25,                    //  68:   decode to ADDC8mn using decoder 25
                                             //  68:  }
  15, 0,                                     //  72:  case 0xf: {
  OPC_Decode, 234, 2, 25,                    //  74:   decode to ADDC8mp using decoder 25
                                             //  74:  }
                                             //  74:  } // switch Inst[7:4]
                                             //  74: }
  7, 27,                                     //  78: case 0x7: {
  OPC_SwitchField, 4, 4,                     //  80:  switch Inst[7:4] {
  10, 4,                                     //  83:  case 0xa: {
  OPC_Decode, 223, 4, 25,                    //  85:   decode to SUBC16mn using decoder 25
                                             //  85:  }
  11, 4,                                     //  89:  case 0xb: {
  OPC_Decode, 224, 4, 25,                    //  91:   decode to SUBC16mp using decoder 25
                                             //  91:  }
  14, 4,                                     //  95:  case 0xe: {
  OPC_Decode, 235, 4, 25,                    //  97:   decode to SUBC8mn using decoder 25
                                             //  97:  }
  15, 0,                                     // 101:  case 0xf: {
  OPC_Decode, 236, 4, 25,                    // 103:   decode to SUBC8mp using decoder 25
                                             // 103:  }
                                             // 103:  } // switch Inst[7:4]
                                             // 103: }
  8, 27,                                     // 107: case 0x8: {
  OPC_SwitchField, 4, 4,                     // 109:  switch Inst[7:4] {
  10, 4,                                     // 112:  case 0xa: {
  OPC_Decode, 199, 4, 25,                    // 114:   decode to SUB16mn using decoder 25
                                             // 114:  }
  11, 4,                                     // 118:  case 0xb: {
  OPC_Decode, 200, 4, 25,                    // 120:   decode to SUB16mp using decoder 25
                                             // 120:  }
  14, 4,                                     // 124:  case 0xe: {
  OPC_Decode, 211, 4, 25,                    // 126:   decode to SUB8mn using decoder 25
                                             // 126:  }
  15, 0,                                     // 130:  case 0xf: {
  OPC_Decode, 212, 4, 25,                    // 132:   decode to SUB8mp using decoder 25
                                             // 132:  }
                                             // 132:  } // switch Inst[7:4]
                                             // 132: }
  9, 27,                                     // 136: case 0x9: {
  OPC_SwitchField, 4, 4,                     // 138:  switch Inst[7:4] {
  10, 4,                                     // 141:  case 0xa: {
  OPC_Decode, 224, 3, 25,                    // 143:   decode to CMP16mn using decoder 25
                                             // 143:  }
  11, 4,                                     // 147:  case 0xb: {
  OPC_Decode, 225, 3, 25,                    // 149:   decode to CMP16mp using decoder 25
                                             // 149:  }
  14, 4,                                     // 153:  case 0xe: {
  OPC_Decode, 236, 3, 25,                    // 155:   decode to CMP8mn using decoder 25
                                             // 155:  }
  15, 0,                                     // 159:  case 0xf: {
  OPC_Decode, 237, 3, 25,                    // 161:   decode to CMP8mp using decoder 25
                                             // 161:  }
                                             // 161:  } // switch Inst[7:4]
                                             // 161: }
  10, 27,                                    // 165: case 0xa: {
  OPC_SwitchField, 4, 4,                     // 167:  switch Inst[7:4] {
  10, 4,                                     // 170:  case 0xa: {
  OPC_Decode, 248, 3, 25,                    // 172:   decode to DADD16mn using decoder 25
                                             // 172:  }
  11, 4,                                     // 176:  case 0xb: {
  OPC_Decode, 249, 3, 25,                    // 178:   decode to DADD16mp using decoder 25
                                             // 178:  }
  14, 4,                                     // 182:  case 0xe: {
  OPC_Decode, 132, 4, 25,                    // 184:   decode to DADD8mn using decoder 25
                                             // 184:  }
  15, 0,                                     // 188:  case 0xf: {
  OPC_Decode, 133, 4, 25,                    // 190:   decode to DADD8mp using decoder 25
                                             // 190:  }
                                             // 190:  } // switch Inst[7:4]
                                             // 190: }
  11, 27,                                    // 194: case 0xb: {
  OPC_SwitchField, 4, 4,                     // 196:  switch Inst[7:4] {
  10, 4,                                     // 199:  case 0xa: {
  OPC_Decode, 192, 3, 25,                    // 201:   decode to BIT16mn using decoder 25
                                             // 201:  }
  11, 4,                                     // 205:  case 0xb: {
  OPC_Decode, 193, 3, 25,                    // 207:   decode to BIT16mp using decoder 25
                                             // 207:  }
  14, 4,                                     // 211:  case 0xe: {
  OPC_Decode, 204, 3, 25,                    // 213:   decode to BIT8mn using decoder 25
                                             // 213:  }
  15, 0,                                     // 217:  case 0xf: {
  OPC_Decode, 205, 3, 25,                    // 219:   decode to BIT8mp using decoder 25
                                             // 219:  }
                                             // 219:  } // switch Inst[7:4]
                                             // 219: }
  12, 27,                                    // 223: case 0xc: {
  OPC_SwitchField, 4, 4,                     // 225:  switch Inst[7:4] {
  10, 4,                                     // 228:  case 0xa: {
  OPC_Decode, 144, 3, 25,                    // 230:   decode to BIC16mn using decoder 25
                                             // 230:  }
  11, 4,                                     // 234:  case 0xb: {
  OPC_Decode, 145, 3, 25,                    // 236:   decode to BIC16mp using decoder 25
                                             // 236:  }
  14, 4,                                     // 240:  case 0xe: {
  OPC_Decode, 156, 3, 25,                    // 242:   decode to BIC8mn using decoder 25
                                             // 242:  }
  15, 0,                                     // 246:  case 0xf: {
  OPC_Decode, 157, 3, 25,                    // 248:   decode to BIC8mp using decoder 25
                                             // 248:  }
                                             // 248:  } // switch Inst[7:4]
                                             // 248: }
  13, 27,                                    // 252: case 0xd: {
  OPC_SwitchField, 4, 4,                     // 254:  switch Inst[7:4] {
  10, 4,                                     // 257:  case 0xa: {
  OPC_Decode, 168, 3, 25,                    // 259:   decode to BIS16mn using decoder 25
                                             // 259:  }
  11, 4,                                     // 263:  case 0xb: {
  OPC_Decode, 169, 3, 25,                    // 265:   decode to BIS16mp using decoder 25
                                             // 265:  }
  14, 4,                                     // 269:  case 0xe: {
  OPC_Decode, 180, 3, 25,                    // 271:   decode to BIS8mn using decoder 25
                                             // 271:  }
  15, 0,                                     // 275:  case 0xf: {
  OPC_Decode, 181, 3, 25,                    // 277:   decode to BIS8mp using decoder 25
                                             // 277:  }
                                             // 277:  } // switch Inst[7:4]
                                             // 277: }
  14, 27,                                    // 281: case 0xe: {
  OPC_SwitchField, 4, 4,                     // 283:  switch Inst[7:4] {
  10, 4,                                     // 286:  case 0xa: {
  OPC_Decode, 131, 5, 25,                    // 288:   decode to XOR16mn using decoder 25
                                             // 288:  }
  11, 4,                                     // 292:  case 0xb: {
  OPC_Decode, 132, 5, 25,                    // 294:   decode to XOR16mp using decoder 25
                                             // 294:  }
  14, 4,                                     // 298:  case 0xe: {
  OPC_Decode, 143, 5, 25,                    // 300:   decode to XOR8mn using decoder 25
                                             // 300:  }
  15, 0,                                     // 304:  case 0xf: {
  OPC_Decode, 144, 5, 25,                    // 306:   decode to XOR8mp using decoder 25
                                             // 306:  }
                                             // 306:  } // switch Inst[7:4]
                                             // 306: }
  15, 0,                                     // 310: case 0xf: {
  OPC_SwitchField, 4, 4,                     // 312:  switch Inst[7:4] {
  10, 4,                                     // 315:  case 0xa: {
  OPC_Decode, 248, 2, 25,                    // 317:   decode to AND16mn using decoder 25
                                             // 317:  }
  11, 4,                                     // 321:  case 0xb: {
  OPC_Decode, 249, 2, 25,                    // 323:   decode to AND16mp using decoder 25
                                             // 323:  }
  14, 4,                                     // 327:  case 0xe: {
  OPC_Decode, 132, 3, 25,                    // 329:   decode to AND8mn using decoder 25
                                             // 329:  }
  15, 0,                                     // 333:  case 0xf: {
  OPC_Decode, 133, 3, 25,                    // 335:   decode to AND8mp using decoder 25
                                             // 335:  }
                                             // 335:  } // switch Inst[7:4]
                                             // 335: }
                                             // 335: } // switch Inst[15:12]
};
static const uint8_t DecoderTableGamma32[467] = {
  OPC_SwitchField, 12, 4,                    //   0: switch Inst[15:12] {
  4, 55,                                     //   3: case 0x4: {
  OPC_SwitchField, 4, 4,                     //   5:  switch Inst[7:4] {
  1, 14,                                     //   8:  case 0x1: {
  OPC_Scope, 8,                              //  10:   try {
  OPC_CheckField, 0, 4, 0,                   //  12:    check Inst[3:0] == 0x0
  OPC_Decode, 214, 3, 28,                    //  16:    decode to Bm using decoder 28
                                             //  16:   } else try {
  OPC_Decode, 150, 4, 29,                    //  20:    decode to MOV16rm using decoder 29
                                             //  20:   }
                                             //  20:  }
  3, 18,                                     //  24:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   //  26:   check Inst[11:8] == 0x0
  OPC_Scope, 8,                              //  30:   try {
  OPC_CheckField, 0, 4, 0,                   //  32:    check Inst[3:0] == 0x0
  OPC_Decode, 213, 3, 24,                    //  36:    decode to Bi using decoder 24
                                             //  36:   } else try {
  OPC_Decode, 149, 4, 30,                    //  40:    decode to MOV16ri using decoder 30
                                             //  40:   }
                                             //  40:  }
  5, 4,                                      //  44:  case 0x5: {
  OPC_Decode, 161, 4, 31,                    //  46:   decode to MOV8rm using decoder 31
                                             //  46:  }
  7, 0,                                      //  50:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   //  52:   check Inst[11:8] == 0x0
  OPC_Decode, 160, 4, 32,                    //  56:   decode to MOV8ri using decoder 32
                                             //  56:  }
                                             //  56:  } // switch Inst[7:4]
                                             //  56: }
  5, 35,                                     //  60: case 0x5: {
  OPC_SwitchField, 4, 4,                     //  62:  switch Inst[7:4] {
  1, 4,                                      //  65:  case 0x1: {
  OPC_Decode, 202, 2, 33,                    //  67:   decode to ADD16rm using decoder 33
                                             //  67:  }
  3, 8,                                      //  71:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   //  73:   check Inst[11:8] == 0x0
  OPC_Decode, 201, 2, 34,                    //  77:   decode to ADD16ri using decoder 34
                                             //  77:  }
  5, 4,                                      //  81:  case 0x5: {
  OPC_Decode, 214, 2, 35,                    //  83:   decode to ADD8rm using decoder 35
                                             //  83:  }
  7, 0,                                      //  87:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   //  89:   check Inst[11:8] == 0x0
  OPC_Decode, 213, 2, 36,                    //  93:   decode to ADD8ri using decoder 36
                                             //  93:  }
                                             //  93:  } // switch Inst[7:4]
                                             //  93: }
  6, 35,                                     //  97: case 0x6: {
  OPC_SwitchField, 4, 4,                     //  99:  switch Inst[7:4] {
  1, 4,                                      // 102:  case 0x1: {
  OPC_Decode, 226, 2, 33,                    // 104:   decode to ADDC16rm using decoder 33
                                             // 104:  }
  3, 8,                                      // 108:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   // 110:   check Inst[11:8] == 0x0
  OPC_Decode, 225, 2, 34,                    // 114:   decode to ADDC16ri using decoder 34
                                             // 114:  }
  5, 4,                                      // 118:  case 0x5: {
  OPC_Decode, 238, 2, 35,                    // 120:   decode to ADDC8rm using decoder 35
                                             // 120:  }
  7, 0,                                      // 124:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   // 126:   check Inst[11:8] == 0x0
  OPC_Decode, 237, 2, 36,                    // 130:   decode to ADDC8ri using decoder 36
                                             // 130:  }
                                             // 130:  } // switch Inst[7:4]
                                             // 130: }
  7, 35,                                     // 134: case 0x7: {
  OPC_SwitchField, 4, 4,                     // 136:  switch Inst[7:4] {
  1, 4,                                      // 139:  case 0x1: {
  OPC_Decode, 228, 4, 33,                    // 141:   decode to SUBC16rm using decoder 33
                                             // 141:  }
  3, 8,                                      // 145:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   // 147:   check Inst[11:8] == 0x0
  OPC_Decode, 227, 4, 34,                    // 151:   decode to SUBC16ri using decoder 34
                                             // 151:  }
  5, 4,                                      // 155:  case 0x5: {
  OPC_Decode, 240, 4, 35,                    // 157:   decode to SUBC8rm using decoder 35
                                             // 157:  }
  7, 0,                                      // 161:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   // 163:   check Inst[11:8] == 0x0
  OPC_Decode, 239, 4, 36,                    // 167:   decode to SUBC8ri using decoder 36
                                             // 167:  }
                                             // 167:  } // switch Inst[7:4]
                                             // 167: }
  8, 35,                                     // 171: case 0x8: {
  OPC_SwitchField, 4, 4,                     // 173:  switch Inst[7:4] {
  1, 4,                                      // 176:  case 0x1: {
  OPC_Decode, 204, 4, 33,                    // 178:   decode to SUB16rm using decoder 33
                                             // 178:  }
  3, 8,                                      // 182:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   // 184:   check Inst[11:8] == 0x0
  OPC_Decode, 203, 4, 34,                    // 188:   decode to SUB16ri using decoder 34
                                             // 188:  }
  5, 4,                                      // 192:  case 0x5: {
  OPC_Decode, 216, 4, 35,                    // 194:   decode to SUB8rm using decoder 35
                                             // 194:  }
  7, 0,                                      // 198:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   // 200:   check Inst[11:8] == 0x0
  OPC_Decode, 215, 4, 36,                    // 204:   decode to SUB8ri using decoder 36
                                             // 204:  }
                                             // 204:  } // switch Inst[7:4]
                                             // 204: }
  9, 35,                                     // 208: case 0x9: {
  OPC_SwitchField, 4, 4,                     // 210:  switch Inst[7:4] {
  1, 4,                                      // 213:  case 0x1: {
  OPC_Decode, 229, 3, 29,                    // 215:   decode to CMP16rm using decoder 29
                                             // 215:  }
  3, 8,                                      // 219:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   // 221:   check Inst[11:8] == 0x0
  OPC_Decode, 228, 3, 30,                    // 225:   decode to CMP16ri using decoder 30
                                             // 225:  }
  5, 4,                                      // 229:  case 0x5: {
  OPC_Decode, 241, 3, 31,                    // 231:   decode to CMP8rm using decoder 31
                                             // 231:  }
  7, 0,                                      // 235:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   // 237:   check Inst[11:8] == 0x0
  OPC_Decode, 240, 3, 32,                    // 241:   decode to CMP8ri using decoder 32
                                             // 241:  }
                                             // 241:  } // switch Inst[7:4]
                                             // 241: }
  10, 35,                                    // 245: case 0xa: {
  OPC_SwitchField, 4, 4,                     // 247:  switch Inst[7:4] {
  1, 4,                                      // 250:  case 0x1: {
  OPC_Decode, 253, 3, 33,                    // 252:   decode to DADD16rm using decoder 33
                                             // 252:  }
  3, 8,                                      // 256:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   // 258:   check Inst[11:8] == 0x0
  OPC_Decode, 252, 3, 34,                    // 262:   decode to DADD16ri using decoder 34
                                             // 262:  }
  5, 4,                                      // 266:  case 0x5: {
  OPC_Decode, 137, 4, 35,                    // 268:   decode to DADD8rm using decoder 35
                                             // 268:  }
  7, 0,                                      // 272:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   // 274:   check Inst[11:8] == 0x0
  OPC_Decode, 136, 4, 36,                    // 278:   decode to DADD8ri using decoder 36
                                             // 278:  }
                                             // 278:  } // switch Inst[7:4]
                                             // 278: }
  11, 35,                                    // 282: case 0xb: {
  OPC_SwitchField, 4, 4,                     // 284:  switch Inst[7:4] {
  1, 4,                                      // 287:  case 0x1: {
  OPC_Decode, 197, 3, 29,                    // 289:   decode to BIT16rm using decoder 29
                                             // 289:  }
  3, 8,                                      // 293:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   // 295:   check Inst[11:8] == 0x0
  OPC_Decode, 196, 3, 30,                    // 299:   decode to BIT16ri using decoder 30
                                             // 299:  }
  5, 4,                                      // 303:  case 0x5: {
  OPC_Decode, 209, 3, 31,                    // 305:   decode to BIT8rm using decoder 31
                                             // 305:  }
  7, 0,                                      // 309:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   // 311:   check Inst[11:8] == 0x0
  OPC_Decode, 208, 3, 32,                    // 315:   decode to BIT8ri using decoder 32
                                             // 315:  }
                                             // 315:  } // switch Inst[7:4]
                                             // 315: }
  12, 35,                                    // 319: case 0xc: {
  OPC_SwitchField, 4, 4,                     // 321:  switch Inst[7:4] {
  1, 4,                                      // 324:  case 0x1: {
  OPC_Decode, 149, 3, 33,                    // 326:   decode to BIC16rm using decoder 33
                                             // 326:  }
  3, 8,                                      // 330:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   // 332:   check Inst[11:8] == 0x0
  OPC_Decode, 148, 3, 34,                    // 336:   decode to BIC16ri using decoder 34
                                             // 336:  }
  5, 4,                                      // 340:  case 0x5: {
  OPC_Decode, 161, 3, 35,                    // 342:   decode to BIC8rm using decoder 35
                                             // 342:  }
  7, 0,                                      // 346:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   // 348:   check Inst[11:8] == 0x0
  OPC_Decode, 160, 3, 36,                    // 352:   decode to BIC8ri using decoder 36
                                             // 352:  }
                                             // 352:  } // switch Inst[7:4]
                                             // 352: }
  13, 35,                                    // 356: case 0xd: {
  OPC_SwitchField, 4, 4,                     // 358:  switch Inst[7:4] {
  1, 4,                                      // 361:  case 0x1: {
  OPC_Decode, 173, 3, 33,                    // 363:   decode to BIS16rm using decoder 33
                                             // 363:  }
  3, 8,                                      // 367:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   // 369:   check Inst[11:8] == 0x0
  OPC_Decode, 172, 3, 34,                    // 373:   decode to BIS16ri using decoder 34
                                             // 373:  }
  5, 4,                                      // 377:  case 0x5: {
  OPC_Decode, 185, 3, 35,                    // 379:   decode to BIS8rm using decoder 35
                                             // 379:  }
  7, 0,                                      // 383:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   // 385:   check Inst[11:8] == 0x0
  OPC_Decode, 184, 3, 36,                    // 389:   decode to BIS8ri using decoder 36
                                             // 389:  }
                                             // 389:  } // switch Inst[7:4]
                                             // 389: }
  14, 35,                                    // 393: case 0xe: {
  OPC_SwitchField, 4, 4,                     // 395:  switch Inst[7:4] {
  1, 4,                                      // 398:  case 0x1: {
  OPC_Decode, 136, 5, 33,                    // 400:   decode to XOR16rm using decoder 33
                                             // 400:  }
  3, 8,                                      // 404:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   // 406:   check Inst[11:8] == 0x0
  OPC_Decode, 135, 5, 34,                    // 410:   decode to XOR16ri using decoder 34
                                             // 410:  }
  5, 4,                                      // 414:  case 0x5: {
  OPC_Decode, 148, 5, 35,                    // 416:   decode to XOR8rm using decoder 35
                                             // 416:  }
  7, 0,                                      // 420:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   // 422:   check Inst[11:8] == 0x0
  OPC_Decode, 147, 5, 36,                    // 426:   decode to XOR8ri using decoder 36
                                             // 426:  }
                                             // 426:  } // switch Inst[7:4]
                                             // 426: }
  15, 0,                                     // 430: case 0xf: {
  OPC_SwitchField, 4, 4,                     // 432:  switch Inst[7:4] {
  1, 4,                                      // 435:  case 0x1: {
  OPC_Decode, 253, 2, 33,                    // 437:   decode to AND16rm using decoder 33
                                             // 437:  }
  3, 8,                                      // 441:  case 0x3: {
  OPC_CheckField, 8, 4, 0,                   // 443:   check Inst[11:8] == 0x0
  OPC_Decode, 252, 2, 34,                    // 447:   decode to AND16ri using decoder 34
                                             // 447:  }
  5, 4,                                      // 451:  case 0x5: {
  OPC_Decode, 137, 3, 35,                    // 453:   decode to AND8rm using decoder 35
                                             // 453:  }
  7, 0,                                      // 457:  case 0x7: {
  OPC_CheckField, 8, 4, 0,                   // 459:   check Inst[11:8] == 0x0
  OPC_Decode, 136, 3, 36,                    // 463:   decode to AND8ri using decoder 36
                                             // 463:  }
                                             // 463:  } // switch Inst[7:4]
                                             // 463: }
                                             // 463: } // switch Inst[15:12]
};
static const uint8_t DecoderTableGamma48[447] = {
  OPC_SwitchField, 12, 4,                    //   0: switch Inst[15:12] {
  4, 35,                                     //   3: case 0x4: {
  OPC_SwitchField, 4, 4,                     //   5:  switch Inst[7:4] {
  9, 4,                                      //   8:  case 0x9: {
  OPC_Decode, 145, 4, 37,                    //  10:   decode to MOV16mm using decoder 37
                                             //  10:  }
  11, 8,                                     //  14:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   //  16:   check Inst[11:8] == 0x0
  OPC_Decode, 144, 4, 38,                    //  20:   decode to MOV16mi using decoder 38
                                             //  20:  }
  13, 4,                                     //  24:  case 0xd: {
  OPC_Decode, 156, 4, 37,                    //  26:   decode to MOV8mm using decoder 37
                                             //  26:  }
  15, 0,                                     //  30:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   //  32:   check Inst[11:8] == 0x0
  OPC_Decode, 155, 4, 38,                    //  36:   decode to MOV8mi using decoder 38
                                             //  36:  }
                                             //  36:  } // switch Inst[7:4]
                                             //  36: }
  5, 35,                                     //  40: case 0x5: {
  OPC_SwitchField, 4, 4,                     //  42:  switch Inst[7:4] {
  9, 4,                                      //  45:  case 0x9: {
  OPC_Decode, 196, 2, 37,                    //  47:   decode to ADD16mm using decoder 37
                                             //  47:  }
  11, 8,                                     //  51:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   //  53:   check Inst[11:8] == 0x0
  OPC_Decode, 195, 2, 38,                    //  57:   decode to ADD16mi using decoder 38
                                             //  57:  }
  13, 4,                                     //  61:  case 0xd: {
  OPC_Decode, 208, 2, 37,                    //  63:   decode to ADD8mm using decoder 37
                                             //  63:  }
  15, 0,                                     //  67:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   //  69:   check Inst[11:8] == 0x0
  OPC_Decode, 207, 2, 38,                    //  73:   decode to ADD8mi using decoder 38
                                             //  73:  }
                                             //  73:  } // switch Inst[7:4]
                                             //  73: }
  6, 35,                                     //  77: case 0x6: {
  OPC_SwitchField, 4, 4,                     //  79:  switch Inst[7:4] {
  9, 4,                                      //  82:  case 0x9: {
  OPC_Decode, 220, 2, 37,                    //  84:   decode to ADDC16mm using decoder 37
                                             //  84:  }
  11, 8,                                     //  88:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   //  90:   check Inst[11:8] == 0x0
  OPC_Decode, 219, 2, 38,                    //  94:   decode to ADDC16mi using decoder 38
                                             //  94:  }
  13, 4,                                     //  98:  case 0xd: {
  OPC_Decode, 232, 2, 37,                    // 100:   decode to ADDC8mm using decoder 37
                                             // 100:  }
  15, 0,                                     // 104:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   // 106:   check Inst[11:8] == 0x0
  OPC_Decode, 231, 2, 38,                    // 110:   decode to ADDC8mi using decoder 38
                                             // 110:  }
                                             // 110:  } // switch Inst[7:4]
                                             // 110: }
  7, 35,                                     // 114: case 0x7: {
  OPC_SwitchField, 4, 4,                     // 116:  switch Inst[7:4] {
  9, 4,                                      // 119:  case 0x9: {
  OPC_Decode, 222, 4, 37,                    // 121:   decode to SUBC16mm using decoder 37
                                             // 121:  }
  11, 8,                                     // 125:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   // 127:   check Inst[11:8] == 0x0
  OPC_Decode, 221, 4, 38,                    // 131:   decode to SUBC16mi using decoder 38
                                             // 131:  }
  13, 4,                                     // 135:  case 0xd: {
  OPC_Decode, 234, 4, 37,                    // 137:   decode to SUBC8mm using decoder 37
                                             // 137:  }
  15, 0,                                     // 141:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   // 143:   check Inst[11:8] == 0x0
  OPC_Decode, 233, 4, 38,                    // 147:   decode to SUBC8mi using decoder 38
                                             // 147:  }
                                             // 147:  } // switch Inst[7:4]
                                             // 147: }
  8, 35,                                     // 151: case 0x8: {
  OPC_SwitchField, 4, 4,                     // 153:  switch Inst[7:4] {
  9, 4,                                      // 156:  case 0x9: {
  OPC_Decode, 198, 4, 37,                    // 158:   decode to SUB16mm using decoder 37
                                             // 158:  }
  11, 8,                                     // 162:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   // 164:   check Inst[11:8] == 0x0
  OPC_Decode, 197, 4, 38,                    // 168:   decode to SUB16mi using decoder 38
                                             // 168:  }
  13, 4,                                     // 172:  case 0xd: {
  OPC_Decode, 210, 4, 37,                    // 174:   decode to SUB8mm using decoder 37
                                             // 174:  }
  15, 0,                                     // 178:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   // 180:   check Inst[11:8] == 0x0
  OPC_Decode, 209, 4, 38,                    // 184:   decode to SUB8mi using decoder 38
                                             // 184:  }
                                             // 184:  } // switch Inst[7:4]
                                             // 184: }
  9, 35,                                     // 188: case 0x9: {
  OPC_SwitchField, 4, 4,                     // 190:  switch Inst[7:4] {
  9, 4,                                      // 193:  case 0x9: {
  OPC_Decode, 223, 3, 37,                    // 195:   decode to CMP16mm using decoder 37
                                             // 195:  }
  11, 8,                                     // 199:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   // 201:   check Inst[11:8] == 0x0
  OPC_Decode, 222, 3, 38,                    // 205:   decode to CMP16mi using decoder 38
                                             // 205:  }
  13, 4,                                     // 209:  case 0xd: {
  OPC_Decode, 235, 3, 37,                    // 211:   decode to CMP8mm using decoder 37
                                             // 211:  }
  15, 0,                                     // 215:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   // 217:   check Inst[11:8] == 0x0
  OPC_Decode, 234, 3, 38,                    // 221:   decode to CMP8mi using decoder 38
                                             // 221:  }
                                             // 221:  } // switch Inst[7:4]
                                             // 221: }
  10, 35,                                    // 225: case 0xa: {
  OPC_SwitchField, 4, 4,                     // 227:  switch Inst[7:4] {
  9, 4,                                      // 230:  case 0x9: {
  OPC_Decode, 247, 3, 37,                    // 232:   decode to DADD16mm using decoder 37
                                             // 232:  }
  11, 8,                                     // 236:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   // 238:   check Inst[11:8] == 0x0
  OPC_Decode, 246, 3, 38,                    // 242:   decode to DADD16mi using decoder 38
                                             // 242:  }
  13, 4,                                     // 246:  case 0xd: {
  OPC_Decode, 131, 4, 37,                    // 248:   decode to DADD8mm using decoder 37
                                             // 248:  }
  15, 0,                                     // 252:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   // 254:   check Inst[11:8] == 0x0
  OPC_Decode, 130, 4, 38,                    // 258:   decode to DADD8mi using decoder 38
                                             // 258:  }
                                             // 258:  } // switch Inst[7:4]
                                             // 258: }
  11, 35,                                    // 262: case 0xb: {
  OPC_SwitchField, 4, 4,                     // 264:  switch Inst[7:4] {
  9, 4,                                      // 267:  case 0x9: {
  OPC_Decode, 191, 3, 37,                    // 269:   decode to BIT16mm using decoder 37
                                             // 269:  }
  11, 8,                                     // 273:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   // 275:   check Inst[11:8] == 0x0
  OPC_Decode, 190, 3, 38,                    // 279:   decode to BIT16mi using decoder 38
                                             // 279:  }
  13, 4,                                     // 283:  case 0xd: {
  OPC_Decode, 203, 3, 37,                    // 285:   decode to BIT8mm using decoder 37
                                             // 285:  }
  15, 0,                                     // 289:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   // 291:   check Inst[11:8] == 0x0
  OPC_Decode, 202, 3, 38,                    // 295:   decode to BIT8mi using decoder 38
                                             // 295:  }
                                             // 295:  } // switch Inst[7:4]
                                             // 295: }
  12, 35,                                    // 299: case 0xc: {
  OPC_SwitchField, 4, 4,                     // 301:  switch Inst[7:4] {
  9, 4,                                      // 304:  case 0x9: {
  OPC_Decode, 143, 3, 37,                    // 306:   decode to BIC16mm using decoder 37
                                             // 306:  }
  11, 8,                                     // 310:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   // 312:   check Inst[11:8] == 0x0
  OPC_Decode, 142, 3, 38,                    // 316:   decode to BIC16mi using decoder 38
                                             // 316:  }
  13, 4,                                     // 320:  case 0xd: {
  OPC_Decode, 155, 3, 37,                    // 322:   decode to BIC8mm using decoder 37
                                             // 322:  }
  15, 0,                                     // 326:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   // 328:   check Inst[11:8] == 0x0
  OPC_Decode, 154, 3, 38,                    // 332:   decode to BIC8mi using decoder 38
                                             // 332:  }
                                             // 332:  } // switch Inst[7:4]
                                             // 332: }
  13, 35,                                    // 336: case 0xd: {
  OPC_SwitchField, 4, 4,                     // 338:  switch Inst[7:4] {
  9, 4,                                      // 341:  case 0x9: {
  OPC_Decode, 167, 3, 37,                    // 343:   decode to BIS16mm using decoder 37
                                             // 343:  }
  11, 8,                                     // 347:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   // 349:   check Inst[11:8] == 0x0
  OPC_Decode, 166, 3, 38,                    // 353:   decode to BIS16mi using decoder 38
                                             // 353:  }
  13, 4,                                     // 357:  case 0xd: {
  OPC_Decode, 179, 3, 37,                    // 359:   decode to BIS8mm using decoder 37
                                             // 359:  }
  15, 0,                                     // 363:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   // 365:   check Inst[11:8] == 0x0
  OPC_Decode, 178, 3, 38,                    // 369:   decode to BIS8mi using decoder 38
                                             // 369:  }
                                             // 369:  } // switch Inst[7:4]
                                             // 369: }
  14, 35,                                    // 373: case 0xe: {
  OPC_SwitchField, 4, 4,                     // 375:  switch Inst[7:4] {
  9, 4,                                      // 378:  case 0x9: {
  OPC_Decode, 130, 5, 37,                    // 380:   decode to XOR16mm using decoder 37
                                             // 380:  }
  11, 8,                                     // 384:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   // 386:   check Inst[11:8] == 0x0
  OPC_Decode, 129, 5, 38,                    // 390:   decode to XOR16mi using decoder 38
                                             // 390:  }
  13, 4,                                     // 394:  case 0xd: {
  OPC_Decode, 142, 5, 37,                    // 396:   decode to XOR8mm using decoder 37
                                             // 396:  }
  15, 0,                                     // 400:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   // 402:   check Inst[11:8] == 0x0
  OPC_Decode, 141, 5, 38,                    // 406:   decode to XOR8mi using decoder 38
                                             // 406:  }
                                             // 406:  } // switch Inst[7:4]
                                             // 406: }
  15, 0,                                     // 410: case 0xf: {
  OPC_SwitchField, 4, 4,                     // 412:  switch Inst[7:4] {
  9, 4,                                      // 415:  case 0x9: {
  OPC_Decode, 247, 2, 37,                    // 417:   decode to AND16mm using decoder 37
                                             // 417:  }
  11, 8,                                     // 421:  case 0xb: {
  OPC_CheckField, 8, 4, 0,                   // 423:   check Inst[11:8] == 0x0
  OPC_Decode, 246, 2, 38,                    // 427:   decode to AND16mi using decoder 38
                                             // 427:  }
  13, 4,                                     // 431:  case 0xd: {
  OPC_Decode, 131, 3, 37,                    // 433:   decode to AND8mm using decoder 37
                                             // 433:  }
  15, 0,                                     // 437:  case 0xf: {
  OPC_CheckField, 8, 4, 0,                   // 439:   check Inst[11:8] == 0x0
  OPC_Decode, 130, 3, 38,                    // 443:   decode to AND8mi using decoder 38
                                             // 443:  }
                                             // 443:  } // switch Inst[7:4]
                                             // 443: }
                                             // 443: } // switch Inst[15:12]
};
// Handling 39 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, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 1:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 2:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 3:
    tmp = fieldFromInstruction(insn, 0, 6);
    if (!Check(S, DecodeCGImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 4:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 5:
    return S;
  case 6:
    tmp = fieldFromInstruction(insn, 0, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 7:
    tmp = fieldFromInstruction(insn, 0, 10);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 10, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 8:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 9:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 10:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 11:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 12:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 13:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 2) << 4;
    tmp |= fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCGImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 14:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 2) << 4;
    tmp |= fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCGImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 15:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 2) << 4;
    tmp |= fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCGImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 16:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 2) << 4;
    tmp |= fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCGImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 17:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 18:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 19:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 20:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 21:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 22:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 23:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 16, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 24:
    tmp = fieldFromInstruction(insn, 16, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 25:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 16, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 26:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 16, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 27:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 16, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 2) << 4;
    tmp |= fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCGImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 28:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 8, 4);
    tmp |= fieldFromInstruction(insn, 16, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 29:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 8, 4);
    tmp |= fieldFromInstruction(insn, 16, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 30:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 31:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 8, 4);
    tmp |= fieldFromInstruction(insn, 16, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 32:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 33:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 8, 4);
    tmp |= fieldFromInstruction(insn, 16, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 34:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 35:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 8, 4);
    tmp |= fieldFromInstruction(insn, 16, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 36:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGR8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 37:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 32, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 8, 4);
    tmp |= fieldFromInstruction(insn, 16, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 38:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 32, 16) << 4;
    if (!Check(S, DecodeMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 16);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  }
}

template <typename InsnType>
static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
                                      InsnType insn, uint64_t Address,
                                      const MCDisassembler *DisAsm,
                                      const MCSubtargetInfo &STI) {
  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_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
