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


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

namespace {

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

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


static const uint8_t DecoderTableThumb16[699] = {
  OPC_SwitchField, 12, 4,                    //   0: switch Inst[15:12] {
  0, 10,                                     //   3: case 0x0: {
  OPC_CheckPredicate, 0,                     //   5:  check predicate 0
  OPC_CheckField, 6, 6, 0,                   //   7:  check Inst[11:6] == 0x0
  OPC_Decode, 130, 35, 0,                    //  11:  decode to tMOVSr using decoder 0
                                             //  11: }
  2, 10,                                     //  15: case 0x2: {
  OPC_CheckPredicate, 0,                     //  17:  check predicate 0
  OPC_CheckField, 11, 1, 1,                  //  19:  check Inst[11] == 0x1
  OPC_Decode, 234, 34, 1,                    //  23:  decode to tCMPi8 using decoder 1
                                             //  23: }
  4, 157, 1,                                 //  27: case 0x4: {
  OPC_SwitchField, 11, 1,                    //  30:  switch Inst[11] {
  0, 143, 1,                                 //  33:  case 0x0: {
  OPC_SwitchField, 8, 3,                     //  36:   switch Inst[10:8] {
  2, 27,                                     //  39:   case 0x2: {
  OPC_SwitchField, 6, 2,                     //  41:    switch Inst[7:6] {
  0, 6,                                      //  44:    case 0x0: {
  OPC_CheckPredicate, 0,                     //  46:     check predicate 0
  OPC_Decode, 162, 35, 2,                    //  48:     decode to tTST using decoder 2
                                             //  48:    }
  2, 6,                                      //  52:    case 0x2: {
  OPC_CheckPredicate, 0,                     //  54:     check predicate 0
  OPC_Decode, 235, 34, 2,                    //  56:     decode to tCMPr using decoder 2
                                             //  56:    }
  3, 0,                                      //  60:    case 0x3: {
  OPC_CheckPredicate, 0,                     //  62:     check predicate 0
  OPC_Decode, 232, 34, 2,                    //  64:     decode to tCMNz using decoder 2
                                             //  64:    }
                                             //  64:    } // switch Inst[7:6]
                                             //  64:   }
  4, 34,                                     //  68:   case 0x4: {
  OPC_Scope, 10,                             //  70:    try {
  OPC_CheckField, 3, 4, 13,                  //  72:     check Inst[6:3] == 0xd
  OPC_CheckPredicate, 0,                     //  76:     check predicate 0
  OPC_Decode, 211, 34, 3,                    //  78:     decode to tADDrSP using decoder 3
  OPC_Scope, 14,                             //  82:    } else try {
  OPC_CheckField, 0, 3, 5,                   //  84:     check Inst[2:0] == 0x5
  OPC_CheckPredicate, 0,                     //  88:     check predicate 0
  OPC_CheckField, 7, 1, 1,                   //  90:     check Inst[7] == 0x1
  OPC_Decode, 215, 34, 3,                    //  94:     decode to tADDspr using decoder 3
                                             //  94:    } else try {
  OPC_CheckPredicate, 0,                     //  98:     check predicate 0
  OPC_Decode, 208, 34, 4,                    // 100:     decode to tADDhirr using decoder 4
                                             // 100:    }
                                             // 100:   }
  5, 6,                                      // 104:   case 0x5: {
  OPC_CheckPredicate, 0,                     // 106:    check predicate 0
  OPC_Decode, 233, 34, 5,                    // 108:    decode to tCMPhir using decoder 5
                                             // 108:   }
  6, 6,                                      // 112:   case 0x6: {
  OPC_CheckPredicate, 0,                     // 114:    check predicate 0
  OPC_Decode, 132, 35, 5,                    // 116:    decode to tMOVr using decoder 5
                                             // 116:   }
  7, 0,                                      // 120:   case 0x7: {
  OPC_SwitchField, 7, 1,                     // 122:    switch Inst[7] {
  0, 24,                                     // 125:    case 0x0: {
  OPC_Scope, 13,                             // 127:     try {
  OPC_CheckField, 2, 1, 1,                   // 129:      check Inst[2] == 0x1
  OPC_CheckPredicate, 1,                     // 133:      check predicate 1
  OPC_SoftFail, 3, 0,                        // 135:      softfail pos=0x00000003 neg=0x00000000
  OPC_Decode, 228, 34, 6,                    // 138:      decode to tBXNS using decoder 6
                                             // 138:     } else try {
  OPC_CheckPredicate, 0,                     // 142:      check predicate 0
  OPC_SoftFail, 7, 0,                        // 144:      softfail pos=0x00000007 neg=0x00000000
  OPC_Decode, 227, 34, 6,                    // 147:      decode to tBX using decoder 6
                                             // 147:     }
                                             // 147:    }
  1, 0,                                      // 151:    case 0x1: {
  OPC_SwitchField, 2, 1,                     // 153:     switch Inst[2] {
  0, 10,                                     // 156:     case 0x0: {
  OPC_CheckPredicate, 2,                     // 158:      check predicate 2
  OPC_CheckField, 0, 2, 0,                   // 160:      check Inst[1:0] == 0x0
  OPC_Decode, 226, 34, 7,                    // 164:      decode to tBLXr using decoder 7
                                             // 164:     }
  1, 0,                                      // 168:     case 0x1: {
  OPC_CheckPredicate, 1,                     // 170:      check predicate 1
  OPC_SoftFail, 3, 0,                        // 172:      softfail pos=0x00000003 neg=0x00000000
  OPC_Decode, 224, 34, 8,                    // 175:      decode to tBLXNSr using decoder 8
                                             // 175:     }
                                             // 175:     } // switch Inst[2]
                                             // 175:    }
                                             // 175:    } // switch Inst[7]
                                             // 175:   }
                                             // 175:   } // switch Inst[10:8]
                                             // 175:  }
  1, 0,                                      // 179:  case 0x1: {
  OPC_CheckPredicate, 0,                     // 181:   check predicate 0
  OPC_Decode, 251, 34, 9,                    // 183:   decode to tLDRpci using decoder 9
                                             // 183:  }
                                             // 183:  } // switch Inst[11]
                                             // 183: }
  5, 67,                                     // 187: case 0x5: {
  OPC_SwitchField, 9, 3,                     // 189:  switch Inst[11:9] {
  0, 6,                                      // 192:  case 0x0: {
  OPC_CheckPredicate, 0,                     // 194:   check predicate 0
  OPC_Decode, 152, 35, 10,                   // 196:   decode to tSTRr using decoder 10
                                             // 196:  }
  1, 6,                                      // 200:  case 0x1: {
  OPC_CheckPredicate, 0,                     // 202:   check predicate 0
  OPC_Decode, 150, 35, 10,                   // 204:   decode to tSTRHr using decoder 10
                                             // 204:  }
  2, 6,                                      // 208:  case 0x2: {
  OPC_CheckPredicate, 0,                     // 210:   check predicate 0
  OPC_Decode, 148, 35, 10,                   // 212:   decode to tSTRBr using decoder 10
                                             // 212:  }
  3, 6,                                      // 216:  case 0x3: {
  OPC_CheckPredicate, 0,                     // 218:   check predicate 0
  OPC_Decode, 248, 34, 10,                   // 220:   decode to tLDRSB using decoder 10
                                             // 220:  }
  4, 6,                                      // 224:  case 0x4: {
  OPC_CheckPredicate, 0,                     // 226:   check predicate 0
  OPC_Decode, 252, 34, 10,                   // 228:   decode to tLDRr using decoder 10
                                             // 228:  }
  5, 6,                                      // 232:  case 0x5: {
  OPC_CheckPredicate, 0,                     // 234:   check predicate 0
  OPC_Decode, 247, 34, 10,                   // 236:   decode to tLDRHr using decoder 10
                                             // 236:  }
  6, 6,                                      // 240:  case 0x6: {
  OPC_CheckPredicate, 0,                     // 242:   check predicate 0
  OPC_Decode, 245, 34, 10,                   // 244:   decode to tLDRBr using decoder 10
                                             // 244:  }
  7, 0,                                      // 248:  case 0x7: {
  OPC_CheckPredicate, 0,                     // 250:   check predicate 0
  OPC_Decode, 249, 34, 10,                   // 252:   decode to tLDRSH using decoder 10
                                             // 252:  }
                                             // 252:  } // switch Inst[11:9]
                                             // 252: }
  6, 19,                                     // 256: case 0x6: {
  OPC_SwitchField, 11, 1,                    // 258:  switch Inst[11] {
  0, 6,                                      // 261:  case 0x0: {
  OPC_CheckPredicate, 0,                     // 263:   check predicate 0
  OPC_Decode, 151, 35, 11,                   // 265:   decode to tSTRi using decoder 11
                                             // 265:  }
  1, 0,                                      // 269:  case 0x1: {
  OPC_CheckPredicate, 0,                     // 271:   check predicate 0
  OPC_Decode, 250, 34, 11,                   // 273:   decode to tLDRi using decoder 11
                                             // 273:  }
                                             // 273:  } // switch Inst[11]
                                             // 273: }
  7, 19,                                     // 277: case 0x7: {
  OPC_SwitchField, 11, 1,                    // 279:  switch Inst[11] {
  0, 6,                                      // 282:  case 0x0: {
  OPC_CheckPredicate, 0,                     // 284:   check predicate 0
  OPC_Decode, 147, 35, 11,                   // 286:   decode to tSTRBi using decoder 11
                                             // 286:  }
  1, 0,                                      // 290:  case 0x1: {
  OPC_CheckPredicate, 0,                     // 292:   check predicate 0
  OPC_Decode, 244, 34, 11,                   // 294:   decode to tLDRBi using decoder 11
                                             // 294:  }
                                             // 294:  } // switch Inst[11]
                                             // 294: }
  8, 19,                                     // 298: case 0x8: {
  OPC_SwitchField, 11, 1,                    // 300:  switch Inst[11] {
  0, 6,                                      // 303:  case 0x0: {
  OPC_CheckPredicate, 0,                     // 305:   check predicate 0
  OPC_Decode, 149, 35, 11,                   // 307:   decode to tSTRHi using decoder 11
                                             // 307:  }
  1, 0,                                      // 311:  case 0x1: {
  OPC_CheckPredicate, 0,                     // 313:   check predicate 0
  OPC_Decode, 246, 34, 11,                   // 315:   decode to tLDRHi using decoder 11
                                             // 315:  }
                                             // 315:  } // switch Inst[11]
                                             // 315: }
  9, 19,                                     // 319: case 0x9: {
  OPC_SwitchField, 11, 1,                    // 321:  switch Inst[11] {
  0, 6,                                      // 324:  case 0x0: {
  OPC_CheckPredicate, 0,                     // 326:   check predicate 0
  OPC_Decode, 153, 35, 12,                   // 328:   decode to tSTRspi using decoder 12
                                             // 328:  }
  1, 0,                                      // 332:  case 0x1: {
  OPC_CheckPredicate, 0,                     // 334:   check predicate 0
  OPC_Decode, 253, 34, 12,                   // 336:   decode to tLDRspi using decoder 12
                                             // 336:  }
                                             // 336:  } // switch Inst[11]
                                             // 336: }
  10, 19,                                    // 340: case 0xa: {
  OPC_SwitchField, 11, 1,                    // 342:  switch Inst[11] {
  0, 6,                                      // 345:  case 0x0: {
  OPC_CheckPredicate, 0,                     // 347:   check predicate 0
  OPC_Decode, 216, 34, 13,                   // 349:   decode to tADR using decoder 13
                                             // 349:  }
  1, 0,                                      // 353:  case 0x1: {
  OPC_CheckPredicate, 0,                     // 355:   check predicate 0
  OPC_Decode, 212, 34, 13,                   // 357:   decode to tADDrSPi using decoder 13
                                             // 357:  }
                                             // 357:  } // switch Inst[11]
                                             // 357: }
  11, 250, 1,                                // 361: case 0xb: {
  OPC_SwitchField, 10, 2,                    // 364:  switch Inst[11:10] {
  0, 84,                                     // 367:  case 0x0: {
  OPC_SwitchField, 8, 1,                     // 369:   switch Inst[8] {
  0, 71,                                     // 372:   case 0x0: {
  OPC_SwitchField, 7, 1,                     // 374:    switch Inst[7] {
  0, 32,                                     // 377:    case 0x0: {
  OPC_SwitchField, 9, 1,                     // 379:     switch Inst[9] {
  0, 6,                                      // 382:     case 0x0: {
  OPC_CheckPredicate, 0,                     // 384:      check predicate 0
  OPC_Decode, 214, 34, 14,                   // 386:      decode to tADDspi using decoder 14
                                             // 386:     }
  1, 0,                                      // 390:     case 0x1: {
  OPC_SwitchField, 6, 1,                     // 392:      switch Inst[6] {
  0, 6,                                      // 395:      case 0x0: {
  OPC_CheckPredicate, 3,                     // 397:       check predicate 3
  OPC_Decode, 160, 35, 2,                    // 399:       decode to tSXTH using decoder 2
                                             // 399:      }
  1, 0,                                      // 403:      case 0x1: {
  OPC_CheckPredicate, 3,                     // 405:       check predicate 3
  OPC_Decode, 159, 35, 2,                    // 407:       decode to tSXTB using decoder 2
                                             // 407:      }
                                             // 407:      } // switch Inst[6]
                                             // 407:     }
                                             // 407:     } // switch Inst[9]
                                             // 407:    }
  1, 0,                                      // 411:    case 0x1: {
  OPC_SwitchField, 9, 1,                     // 413:     switch Inst[9] {
  0, 6,                                      // 416:     case 0x0: {
  OPC_CheckPredicate, 0,                     // 418:      check predicate 0
  OPC_Decode, 157, 35, 14,                   // 420:      decode to tSUBspi using decoder 14
                                             // 420:     }
  1, 0,                                      // 424:     case 0x1: {
  OPC_SwitchField, 6, 1,                     // 426:      switch Inst[6] {
  0, 6,                                      // 429:      case 0x0: {
  OPC_CheckPredicate, 3,                     // 431:       check predicate 3
  OPC_Decode, 165, 35, 2,                    // 433:       decode to tUXTH using decoder 2
                                             // 433:      }
  1, 0,                                      // 437:      case 0x1: {
  OPC_CheckPredicate, 3,                     // 439:       check predicate 3
  OPC_Decode, 164, 35, 2,                    // 441:       decode to tUXTB using decoder 2
                                             // 441:      }
                                             // 441:      } // switch Inst[6]
                                             // 441:     }
                                             // 441:     } // switch Inst[9]
                                             // 441:    }
                                             // 441:    } // switch Inst[7]
                                             // 441:   }
  1, 0,                                      // 445:   case 0x1: {
  OPC_CheckPredicate, 4,                     // 447:    check predicate 4
  OPC_Decode, 231, 34, 15,                   // 449:    decode to tCBZ using decoder 15
                                             // 449:   }
                                             // 449:   } // switch Inst[8]
                                             // 449:  }
  1, 55,                                     // 453:  case 0x1: {
  OPC_SwitchField, 9, 1,                     // 455:   switch Inst[9] {
  0, 6,                                      // 458:   case 0x0: {
  OPC_CheckPredicate, 0,                     // 460:    check predicate 0
  OPC_Decode, 138, 35, 16,                   // 462:    decode to tPUSH using decoder 16
                                             // 462:   }
  1, 0,                                      // 466:   case 0x1: {
  OPC_SwitchField, 5, 4,                     // 468:    switch Inst[8:5] {
  0, 9,                                      // 471:    case 0x0: {
  OPC_CheckPredicate, 5,                     // 473:     check predicate 5
  OPC_SoftFail, 7, 16,                       // 475:     softfail pos=0x00000007 neg=0x00000010
  OPC_Decode, 168, 33, 17,                   // 478:     decode to t2SETPAN using decoder 17
                                             // 478:    }
  2, 14,                                     // 482:    case 0x2: {
  OPC_CheckPredicate, 6,                     // 484:     check predicate 6
  OPC_CheckField, 4, 1, 1,                   // 486:     check Inst[4] == 0x1
  OPC_CheckField, 0, 3, 0,                   // 490:     check Inst[2:0] == 0x0
  OPC_Decode, 145, 35, 17,                   // 494:     decode to tSETEND using decoder 17
                                             // 494:    }
  3, 0,                                      // 498:    case 0x3: {
  OPC_CheckPredicate, 0,                     // 500:     check predicate 0
  OPC_CheckField, 3, 1, 0,                   // 502:     check Inst[3] == 0x0
  OPC_Decode, 236, 34, 18,                   // 506:     decode to tCPS using decoder 18
                                             // 506:    }
                                             // 506:    } // switch Inst[8:5]
                                             // 506:   }
                                             // 506:   } // switch Inst[9]
                                             // 506:  }
  2, 64,                                     // 510:  case 0x2: {
  OPC_SwitchField, 8, 1,                     // 512:   switch Inst[8] {
  0, 51,                                     // 515:   case 0x0: {
  OPC_SwitchField, 6, 2,                     // 517:    switch Inst[7:6] {
  0, 10,                                     // 520:    case 0x0: {
  OPC_CheckPredicate, 3,                     // 522:     check predicate 3
  OPC_CheckField, 9, 1, 1,                   // 524:     check Inst[9] == 0x1
  OPC_Decode, 139, 35, 2,                    // 528:     decode to tREV using decoder 2
                                             // 528:    }
  1, 10,                                     // 532:    case 0x1: {
  OPC_CheckPredicate, 3,                     // 534:     check predicate 3
  OPC_CheckField, 9, 1, 1,                   // 536:     check Inst[9] == 0x1
  OPC_Decode, 140, 35, 2,                    // 540:     decode to tREV16 using decoder 2
                                             // 540:    }
  2, 10,                                     // 544:    case 0x2: {
  OPC_CheckPredicate, 7,                     // 546:     check predicate 7
  OPC_CheckField, 9, 1, 1,                   // 548:     check Inst[9] == 0x1
  OPC_Decode, 239, 34, 19,                   // 552:     decode to tHLT using decoder 19
                                             // 552:    }
  3, 0,                                      // 556:    case 0x3: {
  OPC_CheckPredicate, 3,                     // 558:     check predicate 3
  OPC_CheckField, 9, 1, 1,                   // 560:     check Inst[9] == 0x1
  OPC_Decode, 141, 35, 2,                    // 564:     decode to tREVSH using decoder 2
                                             // 564:    }
                                             // 564:    } // switch Inst[7:6]
                                             // 564:   }
  1, 0,                                      // 568:   case 0x1: {
  OPC_CheckPredicate, 4,                     // 570:    check predicate 4
  OPC_Decode, 230, 34, 15,                   // 572:    decode to tCBNZ using decoder 15
                                             // 572:   }
                                             // 572:   } // switch Inst[8]
                                             // 572:  }
  3, 0,                                      // 576:  case 0x3: {
  OPC_SwitchField, 9, 1,                     // 578:   switch Inst[9] {
  0, 6,                                      // 581:   case 0x0: {
  OPC_CheckPredicate, 0,                     // 583:    check predicate 0
  OPC_Decode, 137, 35, 20,                   // 585:    decode to tPOP using decoder 20
                                             // 585:   }
  1, 0,                                      // 589:   case 0x1: {
  OPC_SwitchField, 8, 1,                     // 591:    switch Inst[8] {
  0, 6,                                      // 594:    case 0x0: {
  OPC_CheckPredicate, 0,                     // 596:     check predicate 0
  OPC_Decode, 222, 34, 21,                   // 598:     decode to tBKPT using decoder 21
                                             // 598:    }
  1, 0,                                      // 602:    case 0x1: {
  OPC_CheckPredicate, 8,                     // 604:     check predicate 8
  OPC_CheckField, 0, 4, 0,                   // 606:     check Inst[3:0] == 0x0
  OPC_Decode, 238, 34, 22,                   // 610:     decode to tHINT using decoder 22
                                             // 610:    }
                                             // 610:    } // switch Inst[8]
                                             // 610:   }
                                             // 610:   } // switch Inst[9]
                                             // 610:  }
                                             // 610:  } // switch Inst[11:10]
                                             // 610: }
  12, 19,                                    // 614: case 0xc: {
  OPC_SwitchField, 11, 1,                    // 616:  switch Inst[11] {
  0, 6,                                      // 619:  case 0x0: {
  OPC_CheckPredicate, 0,                     // 621:   check predicate 0
  OPC_Decode, 146, 35, 23,                   // 623:   decode to tSTMIA_UPD using decoder 23
                                             // 623:  }
  1, 0,                                      // 627:  case 0x1: {
  OPC_CheckPredicate, 0,                     // 629:   check predicate 0
  OPC_Decode, 243, 34, 24,                   // 631:   decode to tLDMIA using decoder 24
                                             // 631:  }
                                             // 631:  } // switch Inst[11]
                                             // 631: }
  13, 50,                                    // 635: case 0xd: {
  OPC_Scope, 21,                             // 637:  try {
  OPC_SwitchField, 0, 12,                    // 639:   switch Inst[11:0] {
  249, 29, 6,                                // 642:   case 0xef9: {
  OPC_CheckPredicate, 0,                     // 645:    check predicate 0
  OPC_Decode, 166, 35, 25,                   // 647:    decode to t__brkdiv0 using decoder 25
                                             // 647:   }
  254, 29, 0,                                // 651:   case 0xefe: {
  OPC_CheckPredicate, 0,                     // 654:    check predicate 0
  OPC_Decode, 161, 35, 25,                   // 656:    decode to tTRAP using decoder 25
                                             // 656:   }
                                             // 656:   } // switch Inst[11:0]
  OPC_Scope, 19,                             // 660:  } else try {
  OPC_SwitchField, 8, 4,                     // 662:   switch Inst[11:8] {
  14, 6,                                     // 665:   case 0xe: {
  OPC_CheckPredicate, 0,                     // 667:    check predicate 0
  OPC_Decode, 163, 35, 21,                   // 669:    decode to tUDF using decoder 21
                                             // 669:   }
  15, 0,                                     // 673:   case 0xf: {
  OPC_CheckPredicate, 0,                     // 675:    check predicate 0
  OPC_Decode, 158, 35, 26,                   // 677:    decode to tSVC using decoder 26
                                             // 677:   }
                                             // 677:   } // switch Inst[11:8]
                                             // 677:  } else try {
  OPC_CheckPredicate, 0,                     // 681:   check predicate 0
  OPC_Decode, 229, 34, 27,                   // 683:   decode to tBcc using decoder 27
                                             // 683:  }
                                             // 683: }
  14, 0,                                     // 687: case 0xe: {
  OPC_CheckPredicate, 0,                     // 689:  check predicate 0
  OPC_CheckField, 11, 1, 0,                  // 691:  check Inst[11] == 0x0
  OPC_Decode, 220, 34, 28,                   // 695:  decode to tB using decoder 28
                                             // 695: }
                                             // 695: } // switch Inst[15:12]
};
static const uint8_t DecoderTableThumb216[11] = {
  OPC_CheckPredicate, 9,                     //  0: check predicate 9
  OPC_CheckField, 8, 8, 191, 1,              //  2: check Inst[15:8] == 0xbf
  OPC_Decode, 136, 32, 29,                   //  7: decode to t2IT using decoder 29
};
static const uint8_t DecoderTableThumbSBit16[197] = {
  OPC_SwitchField, 11, 5,                    //   0: switch Inst[15:11] {
  0, 6,                                      //   3: case 0x0: {
  OPC_CheckPredicate, 0,                     //   5:  check predicate 0
  OPC_Decode, 254, 34, 30,                   //   7:  decode to tLSLri using decoder 30
                                             //   7: }
  1, 6,                                      //  11: case 0x1: {
  OPC_CheckPredicate, 0,                     //  13:  check predicate 0
  OPC_Decode, 128, 35, 30,                   //  15:  decode to tLSRri using decoder 30
                                             //  15: }
  2, 6,                                      //  19: case 0x2: {
  OPC_CheckPredicate, 0,                     //  21:  check predicate 0
  OPC_Decode, 218, 34, 30,                   //  23:  decode to tASRri using decoder 30
                                             //  23: }
  3, 35,                                     //  27: case 0x3: {
  OPC_SwitchField, 9, 2,                     //  29:  switch Inst[10:9] {
  0, 6,                                      //  32:  case 0x0: {
  OPC_CheckPredicate, 0,                     //  34:   check predicate 0
  OPC_Decode, 213, 34, 31,                   //  36:   decode to tADDrr using decoder 31
                                             //  36:  }
  1, 6,                                      //  40:  case 0x1: {
  OPC_CheckPredicate, 0,                     //  42:   check predicate 0
  OPC_Decode, 156, 35, 31,                   //  44:   decode to tSUBrr using decoder 31
                                             //  44:  }
  2, 6,                                      //  48:  case 0x2: {
  OPC_CheckPredicate, 0,                     //  50:   check predicate 0
  OPC_Decode, 209, 34, 32,                   //  52:   decode to tADDi3 using decoder 32
                                             //  52:  }
  3, 0,                                      //  56:  case 0x3: {
  OPC_CheckPredicate, 0,                     //  58:   check predicate 0
  OPC_Decode, 154, 35, 32,                   //  60:   decode to tSUBi3 using decoder 32
                                             //  60:  }
                                             //  60:  } // switch Inst[10:9]
                                             //  60: }
  4, 6,                                      //  64: case 0x4: {
  OPC_CheckPredicate, 0,                     //  66:  check predicate 0
  OPC_Decode, 131, 35, 33,                   //  68:  decode to tMOVi8 using decoder 33
                                             //  68: }
  6, 6,                                      //  72: case 0x6: {
  OPC_CheckPredicate, 0,                     //  74:  check predicate 0
  OPC_Decode, 210, 34, 34,                   //  76:  decode to tADDi8 using decoder 34
                                             //  76: }
  7, 6,                                      //  80: case 0x7: {
  OPC_CheckPredicate, 0,                     //  82:  check predicate 0
  OPC_Decode, 155, 35, 34,                   //  84:  decode to tSUBi8 using decoder 34
                                             //  84: }
  8, 0,                                      //  88: case 0x8: {
  OPC_SwitchField, 6, 5,                     //  90:  switch Inst[10:6] {
  0, 6,                                      //  93:  case 0x0: {
  OPC_CheckPredicate, 0,                     //  95:   check predicate 0
  OPC_Decode, 217, 34, 35,                   //  97:   decode to tAND using decoder 35
                                             //  97:  }
  1, 6,                                      // 101:  case 0x1: {
  OPC_CheckPredicate, 0,                     // 103:   check predicate 0
  OPC_Decode, 237, 34, 35,                   // 105:   decode to tEOR using decoder 35
                                             // 105:  }
  2, 6,                                      // 109:  case 0x2: {
  OPC_CheckPredicate, 0,                     // 111:   check predicate 0
  OPC_Decode, 255, 34, 35,                   // 113:   decode to tLSLrr using decoder 35
                                             // 113:  }
  3, 6,                                      // 117:  case 0x3: {
  OPC_CheckPredicate, 0,                     // 119:   check predicate 0
  OPC_Decode, 129, 35, 35,                   // 121:   decode to tLSRrr using decoder 35
                                             // 121:  }
  4, 6,                                      // 125:  case 0x4: {
  OPC_CheckPredicate, 0,                     // 127:   check predicate 0
  OPC_Decode, 219, 34, 35,                   // 129:   decode to tASRrr using decoder 35
                                             // 129:  }
  5, 6,                                      // 133:  case 0x5: {
  OPC_CheckPredicate, 0,                     // 135:   check predicate 0
  OPC_Decode, 207, 34, 35,                   // 137:   decode to tADC using decoder 35
                                             // 137:  }
  6, 6,                                      // 141:  case 0x6: {
  OPC_CheckPredicate, 0,                     // 143:   check predicate 0
  OPC_Decode, 144, 35, 35,                   // 145:   decode to tSBC using decoder 35
                                             // 145:  }
  7, 6,                                      // 149:  case 0x7: {
  OPC_CheckPredicate, 0,                     // 151:   check predicate 0
  OPC_Decode, 142, 35, 35,                   // 153:   decode to tROR using decoder 35
                                             // 153:  }
  9, 6,                                      // 157:  case 0x9: {
  OPC_CheckPredicate, 0,                     // 159:   check predicate 0
  OPC_Decode, 143, 35, 36,                   // 161:   decode to tRSB using decoder 36
                                             // 161:  }
  12, 6,                                     // 165:  case 0xc: {
  OPC_CheckPredicate, 0,                     // 167:   check predicate 0
  OPC_Decode, 135, 35, 35,                   // 169:   decode to tORR using decoder 35
                                             // 169:  }
  13, 6,                                     // 173:  case 0xd: {
  OPC_CheckPredicate, 0,                     // 175:   check predicate 0
  OPC_Decode, 133, 35, 37,                   // 177:   decode to tMUL using decoder 37
                                             // 177:  }
  14, 6,                                     // 181:  case 0xe: {
  OPC_CheckPredicate, 0,                     // 183:   check predicate 0
  OPC_Decode, 221, 34, 35,                   // 185:   decode to tBIC using decoder 35
                                             // 185:  }
  15, 0,                                     // 189:  case 0xf: {
  OPC_CheckPredicate, 0,                     // 191:   check predicate 0
  OPC_Decode, 134, 35, 36,                   // 193:   decode to tMVN using decoder 36
                                             // 193:  }
                                             // 193:  } // switch Inst[10:6]
                                             // 193: }
                                             // 193: } // switch Inst[15:11]
};
static const uint8_t DecoderTableARM32[5252] = {
  OPC_SwitchField, 25, 3,                    //    0: switch Inst[27:25] {
  0, 220, 17,                                //    3: case 0x0: {
  OPC_SwitchField, 21, 1,                    //    6:  switch Inst[21] {
  0, 164, 9,                                 //    9:  case 0x0: {
  OPC_SwitchField, 24, 1,                    //   12:   switch Inst[24] {
  0, 244, 1,                                 //   15:   case 0x0: {
  OPC_SwitchField, 4, 1,                     //   18:    switch Inst[4] {
  0, 83,                                     //   21:    case 0x0: {
  OPC_SwitchField, 22, 2,                    //   23:     switch Inst[23:22] {
  0, 18,                                     //   26:     case 0x0: {
  OPC_Scope, 10,                             //   28:      try {
  OPC_CheckField, 5, 7, 0,                   //   30:       check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    //   34:       check predicate 10
  OPC_Decode, 175, 6, 38,                    //   36:       decode to ANDrr using decoder 38
                                             //   36:      } else try {
  OPC_CheckPredicate, 10,                    //   40:       check predicate 10
  OPC_Decode, 176, 6, 39,                    //   42:       decode to ANDrsi using decoder 39
                                             //   42:      }
                                             //   42:     }
  1, 18,                                     //   46:     case 0x1: {
  OPC_Scope, 10,                             //   48:      try {
  OPC_CheckField, 5, 7, 0,                   //   50:       check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    //   54:       check predicate 10
  OPC_Decode, 252, 15, 38,                   //   56:       decode to SUBrr using decoder 38
                                             //   56:      } else try {
  OPC_CheckPredicate, 10,                    //   60:       check predicate 10
  OPC_Decode, 253, 15, 39,                   //   62:       decode to SUBrsi using decoder 39
                                             //   62:      }
                                             //   62:     }
  2, 18,                                     //   66:     case 0x2: {
  OPC_Scope, 10,                             //   68:      try {
  OPC_CheckField, 5, 7, 0,                   //   70:       check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    //   74:       check predicate 10
  OPC_Decode, 166, 6, 38,                    //   76:       decode to ADDrr using decoder 38
                                             //   76:      } else try {
  OPC_CheckPredicate, 10,                    //   80:       check predicate 10
  OPC_Decode, 167, 6, 39,                    //   82:       decode to ADDrsi using decoder 39
                                             //   82:      }
                                             //   82:     }
  3, 0,                                      //   86:     case 0x3: {
  OPC_Scope, 10,                             //   88:      try {
  OPC_CheckField, 5, 7, 0,                   //   90:       check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    //   94:       check predicate 10
  OPC_Decode, 246, 14, 38,                   //   96:       decode to SBCrr using decoder 38
                                             //   96:      } else try {
  OPC_CheckPredicate, 10,                    //  100:       check predicate 10
  OPC_Decode, 247, 14, 39,                   //  102:       decode to SBCrsi using decoder 39
                                             //  102:      }
                                             //  102:     }
                                             //  102:     } // switch Inst[23:22]
                                             //  102:    }
  1, 0,                                      //  106:    case 0x1: {
  OPC_SwitchField, 7, 1,                     //  108:     switch Inst[7] {
  0, 35,                                     //  111:     case 0x0: {
  OPC_SwitchField, 22, 2,                    //  113:      switch Inst[23:22] {
  0, 6,                                      //  116:      case 0x0: {
  OPC_CheckPredicate, 10,                    //  118:       check predicate 10
  OPC_Decode, 177, 6, 40,                    //  120:       decode to ANDrsr using decoder 40
                                             //  120:      }
  1, 6,                                      //  124:      case 0x1: {
  OPC_CheckPredicate, 10,                    //  126:       check predicate 10
  OPC_Decode, 254, 15, 40,                   //  128:       decode to SUBrsr using decoder 40
                                             //  128:      }
  2, 6,                                      //  132:      case 0x2: {
  OPC_CheckPredicate, 10,                    //  134:       check predicate 10
  OPC_Decode, 168, 6, 40,                    //  136:       decode to ADDrsr using decoder 40
                                             //  136:      }
  3, 0,                                      //  140:      case 0x3: {
  OPC_CheckPredicate, 10,                    //  142:       check predicate 10
  OPC_Decode, 248, 14, 41,                   //  144:       decode to SBCrsr using decoder 41
                                             //  144:      }
                                             //  144:      } // switch Inst[23:22]
                                             //  144:     }
  1, 0,                                      //  148:     case 0x1: {
  OPC_SwitchField, 5, 2,                     //  150:      switch Inst[6:5] {
  0, 44,                                     //  153:      case 0x0: {
  OPC_SwitchField, 22, 2,                    //  155:       switch Inst[23:22] {
  0, 11,                                     //  158:       case 0x0: {
  OPC_CheckPredicate, 11,                    //  160:        check predicate 11
  OPC_SoftFail, 128, 224, 3, 0,              //  162:        softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 241, 7, 42,                    //  167:        decode to MUL using decoder 42
                                             //  167:       }
  1, 10,                                     //  171:       case 0x1: {
  OPC_CheckPredicate, 11,                    //  173:        check predicate 11
  OPC_CheckField, 20, 1, 0,                  //  175:        check Inst[20] == 0x0
  OPC_Decode, 158, 16, 43,                   //  179:        decode to UMAAL using decoder 43
                                             //  179:       }
  2, 6,                                      //  183:       case 0x2: {
  OPC_CheckPredicate, 11,                    //  185:        check predicate 11
  OPC_Decode, 160, 16, 44,                   //  187:        decode to UMULL using decoder 44
                                             //  187:       }
  3, 0,                                      //  191:       case 0x3: {
  OPC_CheckPredicate, 11,                    //  193:        check predicate 11
  OPC_Decode, 172, 15, 44,                   //  195:        decode to SMULL using decoder 44
                                             //  195:       }
                                             //  195:       } // switch Inst[23:22]
                                             //  195:      }
  1, 19,                                     //  199:      case 0x1: {
  OPC_SwitchField, 20, 1,                    //  201:       switch Inst[20] {
  0, 6,                                      //  204:       case 0x0: {
  OPC_CheckPredicate, 10,                    //  206:        check predicate 10
  OPC_Decode, 241, 15, 45,                   //  208:        decode to STRH_POST using decoder 45
                                             //  208:       }
  1, 0,                                      //  212:       case 0x1: {
  OPC_CheckPredicate, 10,                    //  214:        check predicate 10
  OPC_Decode, 196, 7, 45,                    //  216:        decode to LDRH_POST using decoder 45
                                             //  216:       }
                                             //  216:       } // switch Inst[20]
                                             //  216:      }
  2, 19,                                     //  220:      case 0x2: {
  OPC_SwitchField, 20, 1,                    //  222:       switch Inst[20] {
  0, 6,                                      //  225:       case 0x0: {
  OPC_CheckPredicate, 10,                    //  227:        check predicate 10
  OPC_Decode, 187, 7, 45,                    //  229:        decode to LDRD_POST using decoder 45
                                             //  229:       }
  1, 0,                                      //  233:       case 0x1: {
  OPC_CheckPredicate, 10,                    //  235:        check predicate 10
  OPC_Decode, 201, 7, 45,                    //  237:        decode to LDRSB_POST using decoder 45
                                             //  237:       }
                                             //  237:       } // switch Inst[20]
                                             //  237:      }
  3, 0,                                      //  241:      case 0x3: {
  OPC_SwitchField, 20, 1,                    //  243:       switch Inst[20] {
  0, 6,                                      //  246:       case 0x0: {
  OPC_CheckPredicate, 10,                    //  248:        check predicate 10
  OPC_Decode, 232, 15, 45,                   //  250:        decode to STRD_POST using decoder 45
                                             //  250:       }
  1, 0,                                      //  254:       case 0x1: {
  OPC_CheckPredicate, 10,                    //  256:        check predicate 10
  OPC_Decode, 206, 7, 45,                    //  258:        decode to LDRSH_POST using decoder 45
                                             //  258:       }
                                             //  258:       } // switch Inst[20]
                                             //  258:      }
                                             //  258:      } // switch Inst[6:5]
                                             //  258:     }
                                             //  258:     } // switch Inst[7]
                                             //  258:    }
                                             //  258:    } // switch Inst[4]
                                             //  258:   }
  1, 0,                                      //  262:   case 0x1: {
  OPC_Scope, 203, 6,                         //  264:    try {
  OPC_SwitchField, 22, 2,                    //  267:     switch Inst[23:22] {
  0, 204, 2,                                 //  270:     case 0x0: {
  OPC_SwitchField, 20, 1,                    //  273:      switch Inst[20] {
  0, 253, 1,                                 //  276:      case 0x0: {
  OPC_SwitchField, 5, 1,                     //  279:       switch Inst[5] {
  0, 202, 1,                                 //  282:       case 0x0: {
  OPC_Scope, 118,                            //  285:        try {
  OPC_SwitchField, 28, 4,                    //  287:         switch Inst[31:28] {
  14, 43,                                    //  290:         case 0xe: {
  OPC_SwitchField, 9, 1,                     //  292:          switch Inst[9] {
  0, 18,                                     //  295:          case 0x0: {
  OPC_CheckPredicate, 12,                    //  297:           check predicate 12
  OPC_CheckField, 6, 2, 1,                   //  299:           check Inst[7:6] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  303:           check Inst[4] == 0x0
  OPC_SoftFail, 128, 26, 0,                  //  307:           softfail pos=0x00000d00 neg=0x00000000
  OPC_Decode, 247, 6, 46,                    //  311:           decode to CRC32B using decoder 46
                                             //  311:          }
  1, 0,                                      //  315:          case 0x1: {
  OPC_CheckPredicate, 12,                    //  317:           check predicate 12
  OPC_CheckField, 6, 2, 1,                   //  319:           check Inst[7:6] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  323:           check Inst[4] == 0x0
  OPC_SoftFail, 128, 26, 0,                  //  327:           softfail pos=0x00000d00 neg=0x00000000
  OPC_Decode, 248, 6, 46,                    //  331:           decode to CRC32CB using decoder 46
                                             //  331:          }
                                             //  331:          } // switch Inst[9]
                                             //  331:         }
  15, 0,                                     //  335:         case 0xf: {
  OPC_SwitchField, 10, 8,                    //  337:          switch Inst[17:10] {
  0, 14,                                     //  340:          case 0x0: {
  OPC_CheckPredicate, 10,                    //  342:           check predicate 10
  OPC_CheckField, 9, 1, 0,                   //  344:           check Inst[9] == 0x0
  OPC_CheckField, 0, 5, 0,                   //  348:           check Inst[4:0] == 0x0
  OPC_Decode, 245, 6, 47,                    //  352:           decode to CPS2p using decoder 47
                                             //  352:          }
  64, 18,                                    //  356:          case 0x40: {
  OPC_CheckPredicate, 10,                    //  358:           check predicate 10
  OPC_CheckField, 18, 2, 0,                  //  360:           check Inst[19:18] == 0x0
  OPC_CheckField, 6, 3, 0,                   //  364:           check Inst[8:6] == 0x0
  OPC_CheckField, 0, 5, 0,                   //  368:           check Inst[4:0] == 0x0
  OPC_Decode, 252, 14, 48,                   //  372:           decode to SETEND using decoder 48
                                             //  372:          }
  128, 1, 0,                                 //  376:          case 0x80: {
  OPC_CheckField, 9, 1, 0,                   //  379:           check Inst[9] == 0x0
  OPC_Scope, 14,                             //  383:           try {
  OPC_CheckField, 6, 3, 0,                   //  385:            check Inst[8:6] == 0x0
  OPC_CheckPredicate, 10,                    //  389:            check predicate 10
  OPC_CheckField, 18, 2, 0,                  //  391:            check Inst[19:18] == 0x0
  OPC_Decode, 244, 6, 47,                    //  395:            decode to CPS1p using decoder 47
                                             //  395:           } else try {
  OPC_CheckPredicate, 10,                    //  399:            check predicate 10
  OPC_Decode, 246, 6, 47,                    //  401:            decode to CPS3p using decoder 47
                                             //  401:           }
                                             //  401:          }
                                             //  401:          } // switch Inst[17:10]
                                             //  401:         }
                                             //  401:         } // switch Inst[31:28]
                                             //  401:        } else try {
  OPC_SwitchField, 6, 2,                     //  405:         switch Inst[7:6] {
  0, 24,                                     //  408:         case 0x0: {
  OPC_CheckPredicate, 10,                    //  410:          check predicate 10
  OPC_CheckField, 16, 1, 1,                  //  412:          check Inst[16] == 0x1
  OPC_CheckField, 9, 1, 0,                   //  416:          check Inst[9] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  420:          check Inst[4] == 0x0
  OPC_SoftFail, 143, 26, 128, 128, 56,       //  424:          softfail pos=0x00000d0f neg=0x000e0000
  OPC_Decode, 235, 7, 49,                    //  430:          decode to MRS using decoder 49
                                             //  430:         }
  1, 14,                                     //  434:         case 0x1: {
  OPC_CheckPredicate, 10,                    //  436:          check predicate 10
  OPC_CheckField, 4, 1, 1,                   //  438:          check Inst[4] == 0x1
  OPC_SoftFail, 128, 30, 0,                  //  442:          softfail pos=0x00000f00 neg=0x00000000
  OPC_Decode, 211, 14, 50,                   //  446:          decode to QADD using decoder 50
                                             //  446:         }
  2, 23,                                     //  450:         case 0x2: {
  OPC_SwitchField, 4, 1,                     //  452:          switch Inst[4] {
  0, 6,                                      //  455:          case 0x0: {
  OPC_CheckPredicate, 13,                    //  457:           check predicate 13
  OPC_Decode, 143, 15, 51,                   //  459:           decode to SMLABB using decoder 51
                                             //  459:          }
  1, 0,                                      //  463:          case 0x1: {
  OPC_CheckPredicate, 14,                    //  465:           check predicate 14
  OPC_SoftFail, 128, 30, 0,                  //  467:           softfail pos=0x00000f00 neg=0x00000000
  OPC_Decode, 128, 16, 52,                   //  471:           decode to SWP using decoder 52
                                             //  471:          }
                                             //  471:          } // switch Inst[4]
                                             //  471:         }
  3, 0,                                      //  475:         case 0x3: {
  OPC_CheckPredicate, 13,                    //  477:          check predicate 13
  OPC_CheckField, 4, 1, 0,                   //  479:          check Inst[4] == 0x0
  OPC_Decode, 144, 15, 51,                   //  483:          decode to SMLABT using decoder 51
                                             //  483:         }
                                             //  483:         } // switch Inst[7:6]
                                             //  483:        }
                                             //  483:       }
  1, 0,                                      //  487:       case 0x1: {
  OPC_SwitchField, 6, 2,                     //  489:        switch Inst[7:6] {
  1, 14,                                     //  492:        case 0x1: {
  OPC_CheckPredicate, 15,                    //  494:         check predicate 15
  OPC_CheckField, 28, 4, 14,                 //  496:         check Inst[31:28] == 0xe
  OPC_CheckField, 4, 1, 1,                   //  500:         check Inst[4] == 0x1
  OPC_Decode, 144, 7, 53,                    //  504:         decode to HLT using decoder 53
                                             //  504:        }
  2, 10,                                     //  508:        case 0x2: {
  OPC_CheckPredicate, 13,                    //  510:         check predicate 13
  OPC_CheckField, 4, 1, 0,                   //  512:         check Inst[4] == 0x0
  OPC_Decode, 154, 15, 51,                   //  516:         decode to SMLATB using decoder 51
                                             //  516:        }
  3, 0,                                      //  520:        case 0x3: {
  OPC_CheckPredicate, 13,                    //  522:         check predicate 13
  OPC_CheckField, 4, 1, 0,                   //  524:         check Inst[4] == 0x0
  OPC_Decode, 155, 15, 51,                   //  528:         decode to SMLATT using decoder 51
                                             //  528:        }
                                             //  528:        } // switch Inst[7:6]
                                             //  528:       }
                                             //  528:       } // switch Inst[5]
                                             //  528:      }
  1, 0,                                      //  532:      case 0x1: {
  OPC_SwitchField, 4, 1,                     //  534:       switch Inst[4] {
  0, 49,                                     //  537:       case 0x0: {
  OPC_Scope, 15,                             //  539:        try {
  OPC_CheckField, 5, 7, 0,                   //  541:         check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    //  545:         check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              //  547:         softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 143, 16, 54,                   //  552:         decode to TSTrr using decoder 54
  OPC_Scope, 19,                             //  556:        } else try {
  OPC_CheckField, 5, 3, 0,                   //  558:         check Inst[7:5] == 0x0
  OPC_CheckPredicate, 16,                    //  562:         check predicate 16
  OPC_CheckField, 28, 4, 15,                 //  564:         check Inst[31:28] == 0xf
  OPC_SoftFail, 143, 250, 63, 0,             //  568:         softfail pos=0x000ffd0f neg=0x00000000
  OPC_Decode, 253, 14, 48,                   //  573:         decode to SETPAN using decoder 48
                                             //  573:        } else try {
  OPC_CheckPredicate, 10,                    //  577:         check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              //  579:         softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 144, 16, 55,                   //  584:         decode to TSTrsi using decoder 55
                                             //  584:        }
                                             //  584:       }
  1, 0,                                      //  588:       case 0x1: {
  OPC_CheckPredicate, 10,                    //  590:        check predicate 10
  OPC_CheckField, 7, 1, 0,                   //  592:        check Inst[7] == 0x0
  OPC_SoftFail, 128, 224, 3, 0,              //  596:        softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 145, 16, 56,                   //  601:        decode to TSTrsr using decoder 56
                                             //  601:       }
                                             //  601:       } // switch Inst[4]
                                             //  601:      }
                                             //  601:      } // switch Inst[20]
                                             //  601:     }
  1, 209, 1,                                 //  605:     case 0x1: {
  OPC_SwitchField, 4, 1,                     //  608:      switch Inst[4] {
  0, 125,                                    //  611:      case 0x0: {
  OPC_SwitchField, 20, 1,                    //  613:       switch Inst[20] {
  0, 90,                                     //  616:       case 0x0: {
  OPC_SwitchField, 5, 3,                     //  618:        switch Inst[7:5] {
  0, 16,                                     //  621:        case 0x0: {
  OPC_CheckPredicate, 10,                    //  623:         check predicate 10
  OPC_CheckField, 9, 1, 0,                   //  625:         check Inst[9] == 0x0
  OPC_SoftFail, 143, 26, 128, 128, 60,       //  629:         softfail pos=0x00000d0f neg=0x000f0000
  OPC_Decode, 237, 7, 49,                    //  635:         decode to MRSsys using decoder 49
                                             //  635:        }
  2, 35,                                     //  639:        case 0x2: {
  OPC_SwitchField, 9, 1,                     //  641:         switch Inst[9] {
  0, 14,                                     //  644:         case 0x0: {
  OPC_CheckPredicate, 12,                    //  646:          check predicate 12
  OPC_CheckField, 28, 4, 14,                 //  648:          check Inst[31:28] == 0xe
  OPC_SoftFail, 128, 26, 0,                  //  652:          softfail pos=0x00000d00 neg=0x00000000
  OPC_Decode, 252, 6, 46,                    //  656:          decode to CRC32W using decoder 46
                                             //  656:         }
  1, 0,                                      //  660:         case 0x1: {
  OPC_CheckPredicate, 12,                    //  662:          check predicate 12
  OPC_CheckField, 28, 4, 14,                 //  664:          check Inst[31:28] == 0xe
  OPC_SoftFail, 128, 26, 0,                  //  668:          softfail pos=0x00000d00 neg=0x00000000
  OPC_Decode, 250, 6, 46,                    //  672:          decode to CRC32CW using decoder 46
                                             //  672:         }
                                             //  672:         } // switch Inst[9]
                                             //  672:        }
  4, 6,                                      //  676:        case 0x4: {
  OPC_CheckPredicate, 13,                    //  678:         check predicate 13
  OPC_Decode, 148, 15, 57,                   //  680:         decode to SMLALBB using decoder 57
                                             //  680:        }
  5, 6,                                      //  684:        case 0x5: {
  OPC_CheckPredicate, 13,                    //  686:         check predicate 13
  OPC_Decode, 152, 15, 57,                   //  688:         decode to SMLALTB using decoder 57
                                             //  688:        }
  6, 6,                                      //  692:        case 0x6: {
  OPC_CheckPredicate, 13,                    //  694:         check predicate 13
  OPC_Decode, 149, 15, 57,                   //  696:         decode to SMLALBT using decoder 57
                                             //  696:        }
  7, 0,                                      //  700:        case 0x7: {
  OPC_CheckPredicate, 13,                    //  702:         check predicate 13
  OPC_Decode, 153, 15, 57,                   //  704:         decode to SMLALTT using decoder 57
                                             //  704:        }
                                             //  704:        } // switch Inst[7:5]
                                             //  704:       }
  1, 0,                                      //  708:       case 0x1: {
  OPC_Scope, 15,                             //  710:        try {
  OPC_CheckField, 5, 7, 0,                   //  712:         check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    //  716:         check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              //  718:         softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 241, 6, 58,                    //  723:         decode to CMPrr using decoder 58
                                             //  723:        } else try {
  OPC_CheckPredicate, 10,                    //  727:         check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              //  729:         softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 242, 6, 55,                    //  734:         decode to CMPrsi using decoder 55
                                             //  734:        }
                                             //  734:       }
                                             //  734:       } // switch Inst[20]
                                             //  734:      }
  1, 0,                                      //  738:      case 0x1: {
  OPC_SwitchField, 7, 1,                     //  740:       switch Inst[7] {
  0, 52,                                     //  743:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  745:        switch Inst[20] {
  0, 34,                                     //  748:        case 0x0: {
  OPC_SwitchField, 5, 2,                     //  750:         switch Inst[6:5] {
  2, 10,                                     //  753:         case 0x2: {
  OPC_CheckPredicate, 10,                    //  755:          check predicate 10
  OPC_SoftFail, 128, 30, 0,                  //  757:          softfail pos=0x00000f00 neg=0x00000000
  OPC_Decode, 215, 14, 59,                   //  761:          decode to QDADD using decoder 59
                                             //  761:         }
  3, 0,                                      //  765:         case 0x3: {
  OPC_CheckPredicate, 17,                    //  767:          check predicate 17
  OPC_SoftFail, 128, 128, 128, 128, 1, 128, 128, 128, 128, 14, 
                                             //  769:          softfail pos=0x10000000 neg=0xe0000000
  OPC_Decode, 145, 7, 53,                    //  780:          decode to HVC using decoder 53
                                             //  780:         }
                                             //  780:         } // switch Inst[6:5]
                                             //  780:        }
  1, 0,                                      //  784:        case 0x1: {
  OPC_CheckPredicate, 10,                    //  786:         check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              //  788:         softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 243, 6, 56,                    //  793:         decode to CMPrsr using decoder 56
                                             //  793:        }
                                             //  793:        } // switch Inst[20]
                                             //  793:       }
  1, 0,                                      //  797:       case 0x1: {
  OPC_CheckPredicate, 14,                    //  799:        check predicate 14
  OPC_CheckField, 20, 1, 0,                  //  801:        check Inst[20] == 0x0
  OPC_CheckField, 5, 2, 0,                   //  805:        check Inst[6:5] == 0x0
  OPC_SoftFail, 128, 30, 0,                  //  809:        softfail pos=0x00000f00 neg=0x00000000
  OPC_Decode, 129, 16, 52,                   //  813:        decode to SWPB using decoder 52
                                             //  813:       }
                                             //  813:       } // switch Inst[7]
                                             //  813:      }
                                             //  813:      } // switch Inst[4]
                                             //  813:     }
  2, 144, 1,                                 //  817:     case 0x2: {
  OPC_SwitchField, 4, 1,                     //  820:      switch Inst[4] {
  0, 18,                                     //  823:      case 0x0: {
  OPC_Scope, 10,                             //  825:       try {
  OPC_CheckField, 5, 7, 0,                   //  827:        check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    //  831:        check predicate 10
  OPC_Decode, 200, 14, 38,                   //  833:        decode to ORRrr using decoder 38
                                             //  833:       } else try {
  OPC_CheckPredicate, 10,                    //  837:        check predicate 10
  OPC_Decode, 201, 14, 39,                   //  839:        decode to ORRrsi using decoder 39
                                             //  839:       }
                                             //  839:      }
  1, 0,                                      //  843:      case 0x1: {
  OPC_SwitchField, 7, 1,                     //  845:       switch Inst[7] {
  0, 6,                                      //  848:       case 0x0: {
  OPC_CheckPredicate, 10,                    //  850:        check predicate 10
  OPC_Decode, 202, 14, 40,                   //  852:        decode to ORRrsr using decoder 40
                                             //  852:       }
  1, 0,                                      //  856:       case 0x1: {
  OPC_SwitchField, 8, 4,                     //  858:        switch Inst[11:8] {
  12, 35,                                    //  861:        case 0xc: {
  OPC_SwitchField, 20, 1,                    //  863:         switch Inst[20] {
  0, 14,                                     //  866:         case 0x0: {
  OPC_CheckPredicate, 18,                    //  868:          check predicate 18
  OPC_CheckField, 12, 4, 15,                 //  870:          check Inst[15:12] == 0xf
  OPC_CheckField, 5, 2, 0,                   //  874:          check Inst[6:5] == 0x0
  OPC_Decode, 208, 15, 60,                   //  878:          decode to STL using decoder 60
                                             //  878:         }
  1, 0,                                      //  882:         case 0x1: {
  OPC_CheckPredicate, 18,                    //  884:          check predicate 18
  OPC_CheckField, 5, 2, 0,                   //  886:          check Inst[6:5] == 0x0
  OPC_CheckField, 0, 4, 15,                  //  890:          check Inst[3:0] == 0xf
  OPC_Decode, 147, 7, 61,                    //  894:          decode to LDA using decoder 61
                                             //  894:         }
                                             //  894:         } // switch Inst[20]
                                             //  894:        }
  14, 31,                                    //  898:        case 0xe: {
  OPC_SwitchField, 20, 1,                    //  900:         switch Inst[20] {
  0, 10,                                     //  903:         case 0x0: {
  OPC_CheckPredicate, 19,                    //  905:          check predicate 19
  OPC_CheckField, 5, 2, 0,                   //  907:          check Inst[6:5] == 0x0
  OPC_Decode, 210, 15, 62,                   //  911:          decode to STLEX using decoder 62
                                             //  911:         }
  1, 0,                                      //  915:         case 0x1: {
  OPC_CheckPredicate, 19,                    //  917:          check predicate 19
  OPC_CheckField, 5, 2, 0,                   //  919:          check Inst[6:5] == 0x0
  OPC_CheckField, 0, 4, 15,                  //  923:          check Inst[3:0] == 0xf
  OPC_Decode, 149, 7, 61,                    //  927:          decode to LDAEX using decoder 61
                                             //  927:         }
                                             //  927:         } // switch Inst[20]
                                             //  927:        }
  15, 0,                                     //  931:        case 0xf: {
  OPC_SwitchField, 20, 1,                    //  933:         switch Inst[20] {
  0, 10,                                     //  936:         case 0x0: {
  OPC_CheckPredicate, 10,                    //  938:          check predicate 10
  OPC_CheckField, 5, 2, 0,                   //  940:          check Inst[6:5] == 0x0
  OPC_Decode, 234, 15, 62,                   //  944:          decode to STREX using decoder 62
                                             //  944:         }
  1, 0,                                      //  948:         case 0x1: {
  OPC_CheckPredicate, 10,                    //  950:          check predicate 10
  OPC_CheckField, 5, 2, 0,                   //  952:          check Inst[6:5] == 0x0
  OPC_CheckField, 0, 4, 15,                  //  956:          check Inst[3:0] == 0xf
  OPC_Decode, 189, 7, 61,                    //  960:          decode to LDREX using decoder 61
                                             //  960:         }
                                             //  960:         } // switch Inst[20]
                                             //  960:        }
                                             //  960:        } // switch Inst[11:8]
                                             //  960:       }
                                             //  960:       } // switch Inst[7]
                                             //  960:      }
                                             //  960:      } // switch Inst[4]
                                             //  960:     }
  3, 0,                                      //  964:     case 0x3: {
  OPC_SwitchField, 4, 1,                     //  966:      switch Inst[4] {
  0, 18,                                     //  969:      case 0x0: {
  OPC_Scope, 10,                             //  971:       try {
  OPC_CheckField, 5, 7, 0,                   //  973:        check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    //  977:        check predicate 10
  OPC_Decode, 188, 6, 38,                    //  979:        decode to BICrr using decoder 38
                                             //  979:       } else try {
  OPC_CheckPredicate, 10,                    //  983:        check predicate 10
  OPC_Decode, 189, 6, 39,                    //  985:        decode to BICrsi using decoder 39
                                             //  985:       }
                                             //  985:      }
  1, 0,                                      //  989:      case 0x1: {
  OPC_SwitchField, 7, 1,                     //  991:       switch Inst[7] {
  0, 6,                                      //  994:       case 0x0: {
  OPC_CheckPredicate, 10,                    //  996:        check predicate 10
  OPC_Decode, 190, 6, 40,                    //  998:        decode to BICrsr using decoder 40
                                             //  998:       }
  1, 0,                                      // 1002:       case 0x1: {
  OPC_SwitchField, 8, 4,                     // 1004:        switch Inst[11:8] {
  12, 35,                                    // 1007:        case 0xc: {
  OPC_SwitchField, 20, 1,                    // 1009:         switch Inst[20] {
  0, 14,                                     // 1012:         case 0x0: {
  OPC_CheckPredicate, 18,                    // 1014:          check predicate 18
  OPC_CheckField, 12, 4, 15,                 // 1016:          check Inst[15:12] == 0xf
  OPC_CheckField, 5, 2, 0,                   // 1020:          check Inst[6:5] == 0x0
  OPC_Decode, 209, 15, 60,                   // 1024:          decode to STLB using decoder 60
                                             // 1024:         }
  1, 0,                                      // 1028:         case 0x1: {
  OPC_CheckPredicate, 18,                    // 1030:          check predicate 18
  OPC_CheckField, 5, 2, 0,                   // 1032:          check Inst[6:5] == 0x0
  OPC_CheckField, 0, 4, 15,                  // 1036:          check Inst[3:0] == 0xf
  OPC_Decode, 148, 7, 61,                    // 1040:          decode to LDAB using decoder 61
                                             // 1040:         }
                                             // 1040:         } // switch Inst[20]
                                             // 1040:        }
  14, 31,                                    // 1044:        case 0xe: {
  OPC_SwitchField, 20, 1,                    // 1046:         switch Inst[20] {
  0, 10,                                     // 1049:         case 0x0: {
  OPC_CheckPredicate, 19,                    // 1051:          check predicate 19
  OPC_CheckField, 5, 2, 0,                   // 1053:          check Inst[6:5] == 0x0
  OPC_Decode, 211, 15, 62,                   // 1057:          decode to STLEXB using decoder 62
                                             // 1057:         }
  1, 0,                                      // 1061:         case 0x1: {
  OPC_CheckPredicate, 19,                    // 1063:          check predicate 19
  OPC_CheckField, 5, 2, 0,                   // 1065:          check Inst[6:5] == 0x0
  OPC_CheckField, 0, 4, 15,                  // 1069:          check Inst[3:0] == 0xf
  OPC_Decode, 150, 7, 61,                    // 1073:          decode to LDAEXB using decoder 61
                                             // 1073:         }
                                             // 1073:         } // switch Inst[20]
                                             // 1073:        }
  15, 0,                                     // 1077:        case 0xf: {
  OPC_SwitchField, 20, 1,                    // 1079:         switch Inst[20] {
  0, 10,                                     // 1082:         case 0x0: {
  OPC_CheckPredicate, 10,                    // 1084:          check predicate 10
  OPC_CheckField, 5, 2, 0,                   // 1086:          check Inst[6:5] == 0x0
  OPC_Decode, 235, 15, 62,                   // 1090:          decode to STREXB using decoder 62
                                             // 1090:         }
  1, 0,                                      // 1094:         case 0x1: {
  OPC_CheckPredicate, 10,                    // 1096:          check predicate 10
  OPC_CheckField, 5, 2, 0,                   // 1098:          check Inst[6:5] == 0x0
  OPC_CheckField, 0, 4, 15,                  // 1102:          check Inst[3:0] == 0xf
  OPC_Decode, 190, 7, 61,                    // 1106:          decode to LDREXB using decoder 61
                                             // 1106:         }
                                             // 1106:         } // switch Inst[20]
                                             // 1106:        }
                                             // 1106:        } // switch Inst[11:8]
                                             // 1106:       }
                                             // 1106:       } // switch Inst[7]
                                             // 1106:      }
                                             // 1106:      } // switch Inst[4]
                                             // 1106:     }
                                             // 1106:     } // switch Inst[23:22]
                                             // 1106:    } else try {
  OPC_SwitchField, 4, 4,                     // 1110:     switch Inst[7:4] {
  0, 22,                                     // 1113:     case 0x0: {
  OPC_CheckPredicate, 17,                    // 1115:      check predicate 17
  OPC_CheckField, 23, 1, 0,                  // 1117:      check Inst[23] == 0x0
  OPC_CheckField, 20, 1, 0,                  // 1121:      check Inst[20] == 0x0
  OPC_CheckField, 9, 3, 1,                   // 1125:      check Inst[11:9] == 0x1
  OPC_CheckField, 0, 4, 0,                   // 1129:      check Inst[3:0] == 0x0
  OPC_Decode, 236, 7, 63,                    // 1133:      decode to MRSbanked using decoder 63
                                             // 1133:     }
  11, 19,                                    // 1137:     case 0xb: {
  OPC_SwitchField, 20, 1,                    // 1139:      switch Inst[20] {
  0, 6,                                      // 1142:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 1144:       check predicate 10
  OPC_Decode, 238, 15, 45,                   // 1146:       decode to STRH using decoder 45
                                             // 1146:      }
  1, 0,                                      // 1150:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 1152:       check predicate 10
  OPC_Decode, 193, 7, 45,                    // 1154:       decode to LDRH using decoder 45
                                             // 1154:      }
                                             // 1154:      } // switch Inst[20]
                                             // 1154:     }
  13, 19,                                    // 1158:     case 0xd: {
  OPC_SwitchField, 20, 1,                    // 1160:      switch Inst[20] {
  0, 6,                                      // 1163:      case 0x0: {
  OPC_CheckPredicate, 13,                    // 1165:       check predicate 13
  OPC_Decode, 186, 7, 45,                    // 1167:       decode to LDRD using decoder 45
                                             // 1167:      }
  1, 0,                                      // 1171:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 1173:       check predicate 10
  OPC_Decode, 198, 7, 45,                    // 1175:       decode to LDRSB using decoder 45
                                             // 1175:      }
                                             // 1175:      } // switch Inst[20]
                                             // 1175:     }
  15, 0,                                     // 1179:     case 0xf: {
  OPC_SwitchField, 20, 1,                    // 1181:      switch Inst[20] {
  0, 6,                                      // 1184:      case 0x0: {
  OPC_CheckPredicate, 13,                    // 1186:       check predicate 13
  OPC_Decode, 231, 15, 45,                   // 1188:       decode to STRD using decoder 45
                                             // 1188:      }
  1, 0,                                      // 1192:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 1194:       check predicate 10
  OPC_Decode, 203, 7, 45,                    // 1196:       decode to LDRSH using decoder 45
                                             // 1196:      }
                                             // 1196:      } // switch Inst[20]
                                             // 1196:     }
                                             // 1196:     } // switch Inst[7:4]
                                             // 1196:    }
                                             // 1196:   }
                                             // 1196:   } // switch Inst[24]
                                             // 1196:  }
  1, 0,                                      // 1200:  case 0x1: {
  OPC_SwitchField, 4, 1,                     // 1202:   switch Inst[4] {
  0, 193, 3,                                 // 1205:   case 0x0: {
  OPC_SwitchField, 23, 2,                    // 1208:    switch Inst[24:23] {
  0, 43,                                     // 1211:    case 0x0: {
  OPC_SwitchField, 22, 1,                    // 1213:     switch Inst[22] {
  0, 18,                                     // 1216:     case 0x0: {
  OPC_Scope, 10,                             // 1218:      try {
  OPC_CheckField, 5, 7, 0,                   // 1220:       check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    // 1224:       check predicate 10
  OPC_Decode, 129, 7, 38,                    // 1226:       decode to EORrr using decoder 38
                                             // 1226:      } else try {
  OPC_CheckPredicate, 10,                    // 1230:       check predicate 10
  OPC_Decode, 130, 7, 39,                    // 1232:       decode to EORrsi using decoder 39
                                             // 1232:      }
                                             // 1232:     }
  1, 0,                                      // 1236:     case 0x1: {
  OPC_Scope, 10,                             // 1238:      try {
  OPC_CheckField, 5, 7, 0,                   // 1240:       check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    // 1244:       check predicate 10
  OPC_Decode, 234, 14, 38,                   // 1246:       decode to RSBrr using decoder 38
                                             // 1246:      } else try {
  OPC_CheckPredicate, 10,                    // 1250:       check predicate 10
  OPC_Decode, 235, 14, 39,                   // 1252:       decode to RSBrsi using decoder 39
                                             // 1252:      }
                                             // 1252:     }
                                             // 1252:     } // switch Inst[22]
                                             // 1252:    }
  1, 43,                                     // 1256:    case 0x1: {
  OPC_SwitchField, 22, 1,                    // 1258:     switch Inst[22] {
  0, 18,                                     // 1261:     case 0x0: {
  OPC_Scope, 10,                             // 1263:      try {
  OPC_CheckField, 5, 7, 0,                   // 1265:       check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    // 1269:       check predicate 10
  OPC_Decode, 162, 6, 38,                    // 1271:       decode to ADCrr using decoder 38
                                             // 1271:      } else try {
  OPC_CheckPredicate, 10,                    // 1275:       check predicate 10
  OPC_Decode, 163, 6, 39,                    // 1277:       decode to ADCrsi using decoder 39
                                             // 1277:      }
                                             // 1277:     }
  1, 0,                                      // 1281:     case 0x1: {
  OPC_Scope, 10,                             // 1283:      try {
  OPC_CheckField, 5, 7, 0,                   // 1285:       check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    // 1289:       check predicate 10
  OPC_Decode, 238, 14, 38,                   // 1291:       decode to RSCrr using decoder 38
                                             // 1291:      } else try {
  OPC_CheckPredicate, 10,                    // 1295:       check predicate 10
  OPC_Decode, 239, 14, 39,                   // 1297:       decode to RSCrsi using decoder 39
                                             // 1297:      }
                                             // 1297:     }
                                             // 1297:     } // switch Inst[22]
                                             // 1297:    }
  2, 137, 2,                                 // 1301:    case 0x2: {
  OPC_SwitchField, 20, 1,                    // 1304:     switch Inst[20] {
  0, 194, 1,                                 // 1307:     case 0x0: {
  OPC_SwitchField, 5, 3,                     // 1310:      switch Inst[7:5] {
  0, 23,                                     // 1313:      case 0x0: {
  OPC_SwitchField, 9, 7,                     // 1315:       switch Inst[15:9] {
  120, 10,                                   // 1318:       case 0x78: {
  OPC_CheckPredicate, 10,                    // 1320:        check predicate 10
  OPC_CheckField, 8, 1, 0,                   // 1322:        check Inst[8] == 0x0
  OPC_Decode, 238, 7, 64,                    // 1326:        decode to MSR using decoder 64
                                             // 1326:       }
  121, 0,                                    // 1330:       case 0x79: {
  OPC_CheckPredicate, 17,                    // 1332:        check predicate 17
  OPC_Decode, 239, 7, 65,                    // 1334:        decode to MSRbanked using decoder 65
                                             // 1334:       }
                                             // 1334:       } // switch Inst[15:9]
                                             // 1334:      }
  1, 15,                                     // 1338:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 1340:       check predicate 10
  OPC_CheckField, 22, 1, 0,                  // 1342:       check Inst[22] == 0x0
  OPC_CheckField, 8, 12, 255, 31,            // 1346:       check Inst[19:8] == 0xfff
  OPC_Decode, 198, 6, 66,                    // 1351:       decode to BXJ using decoder 66
                                             // 1351:      }
  2, 43,                                     // 1355:      case 0x2: {
  OPC_SwitchField, 9, 1,                     // 1357:       switch Inst[9] {
  0, 18,                                     // 1360:       case 0x0: {
  OPC_CheckPredicate, 12,                    // 1362:        check predicate 12
  OPC_CheckField, 28, 4, 14,                 // 1364:        check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  // 1368:        check Inst[22] == 0x0
  OPC_SoftFail, 128, 26, 0,                  // 1372:        softfail pos=0x00000d00 neg=0x00000000
  OPC_Decode, 251, 6, 46,                    // 1376:        decode to CRC32H using decoder 46
                                             // 1376:       }
  1, 0,                                      // 1380:       case 0x1: {
  OPC_CheckPredicate, 12,                    // 1382:        check predicate 12
  OPC_CheckField, 28, 4, 14,                 // 1384:        check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  // 1388:        check Inst[22] == 0x0
  OPC_SoftFail, 128, 26, 0,                  // 1392:        softfail pos=0x00000d00 neg=0x00000000
  OPC_Decode, 249, 6, 46,                    // 1396:        decode to CRC32CH using decoder 46
                                             // 1396:       }
                                             // 1396:       } // switch Inst[9]
                                             // 1396:      }
  3, 18,                                     // 1400:      case 0x3: {
  OPC_CheckPredicate, 17,                    // 1402:       check predicate 17
  OPC_CheckField, 22, 1, 1,                  // 1404:       check Inst[22] == 0x1
  OPC_CheckField, 8, 12, 0,                  // 1408:       check Inst[19:8] == 0x0
  OPC_CheckField, 0, 4, 14,                  // 1412:       check Inst[3:0] == 0xe
  OPC_Decode, 132, 7, 67,                    // 1416:       decode to ERET using decoder 67
                                             // 1416:      }
  4, 19,                                     // 1420:      case 0x4: {
  OPC_SwitchField, 22, 1,                    // 1422:       switch Inst[22] {
  0, 6,                                      // 1425:       case 0x0: {
  OPC_CheckPredicate, 13,                    // 1427:        check predicate 13
  OPC_Decode, 156, 15, 51,                   // 1429:        decode to SMLAWB using decoder 51
                                             // 1429:       }
  1, 0,                                      // 1433:       case 0x1: {
  OPC_CheckPredicate, 13,                    // 1435:        check predicate 13
  OPC_Decode, 170, 15, 68,                   // 1437:        decode to SMULBB using decoder 68
                                             // 1437:       }
                                             // 1437:       } // switch Inst[22]
                                             // 1437:      }
  5, 19,                                     // 1441:      case 0x5: {
  OPC_SwitchField, 22, 1,                    // 1443:       switch Inst[22] {
  0, 6,                                      // 1446:       case 0x0: {
  OPC_CheckPredicate, 13,                    // 1448:        check predicate 13
  OPC_Decode, 175, 15, 68,                   // 1450:        decode to SMULWB using decoder 68
                                             // 1450:       }
  1, 0,                                      // 1454:       case 0x1: {
  OPC_CheckPredicate, 13,                    // 1456:        check predicate 13
  OPC_Decode, 173, 15, 68,                   // 1458:        decode to SMULTB using decoder 68
                                             // 1458:       }
                                             // 1458:       } // switch Inst[22]
                                             // 1458:      }
  6, 19,                                     // 1462:      case 0x6: {
  OPC_SwitchField, 22, 1,                    // 1464:       switch Inst[22] {
  0, 6,                                      // 1467:       case 0x0: {
  OPC_CheckPredicate, 13,                    // 1469:        check predicate 13
  OPC_Decode, 157, 15, 51,                   // 1471:        decode to SMLAWT using decoder 51
                                             // 1471:       }
  1, 0,                                      // 1475:       case 0x1: {
  OPC_CheckPredicate, 13,                    // 1477:        check predicate 13
  OPC_Decode, 171, 15, 68,                   // 1479:        decode to SMULBT using decoder 68
                                             // 1479:       }
                                             // 1479:       } // switch Inst[22]
                                             // 1479:      }
  7, 0,                                      // 1483:      case 0x7: {
  OPC_SwitchField, 22, 1,                    // 1485:       switch Inst[22] {
  0, 6,                                      // 1488:       case 0x0: {
  OPC_CheckPredicate, 13,                    // 1490:        check predicate 13
  OPC_Decode, 176, 15, 68,                   // 1492:        decode to SMULWT using decoder 68
                                             // 1492:       }
  1, 0,                                      // 1496:       case 0x1: {
  OPC_CheckPredicate, 13,                    // 1498:        check predicate 13
  OPC_Decode, 174, 15, 68,                   // 1500:        decode to SMULTT using decoder 68
                                             // 1500:       }
                                             // 1500:       } // switch Inst[22]
                                             // 1500:      }
                                             // 1500:      } // switch Inst[7:5]
                                             // 1500:     }
  1, 0,                                      // 1504:     case 0x1: {
  OPC_SwitchField, 22, 1,                    // 1506:      switch Inst[22] {
  0, 28,                                     // 1509:      case 0x0: {
  OPC_Scope, 15,                             // 1511:       try {
  OPC_CheckField, 5, 7, 0,                   // 1513:        check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    // 1517:        check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              // 1519:        softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 137, 16, 58,                   // 1524:        decode to TEQrr using decoder 58
                                             // 1524:       } else try {
  OPC_CheckPredicate, 10,                    // 1528:        check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              // 1530:        softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 138, 16, 55,                   // 1535:        decode to TEQrsi using decoder 55
                                             // 1535:       }
                                             // 1535:      }
  1, 0,                                      // 1539:      case 0x1: {
  OPC_Scope, 15,                             // 1541:       try {
  OPC_CheckField, 5, 7, 0,                   // 1543:        check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    // 1547:        check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              // 1549:        softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 237, 6, 58,                    // 1554:        decode to CMNzrr using decoder 58
                                             // 1554:       } else try {
  OPC_CheckPredicate, 10,                    // 1558:        check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              // 1560:        softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 238, 6, 55,                    // 1565:        decode to CMNzrsi using decoder 55
                                             // 1565:       }
                                             // 1565:      }
                                             // 1565:      } // switch Inst[22]
                                             // 1565:     }
                                             // 1565:     } // switch Inst[20]
                                             // 1565:    }
  3, 0,                                      // 1569:    case 0x3: {
  OPC_SwitchField, 22, 1,                    // 1571:     switch Inst[22] {
  0, 51,                                     // 1574:     case 0x0: {
  OPC_Scope, 15,                             // 1576:      try {
  OPC_CheckField, 0, 4, 14,                  // 1578:       check Inst[3:0] == 0xe
  OPC_CheckPredicate, 10,                    // 1582:       check predicate 10
  OPC_CheckField, 5, 16, 128, 15,            // 1584:       check Inst[20:5] == 0x780
  OPC_Decode, 223, 7, 67,                    // 1589:       decode to MOVPCLR using decoder 67
  OPC_Scope, 22,                             // 1593:      } else try {
  OPC_CheckField, 5, 7, 0,                   // 1595:       check Inst[11:5] == 0x0
  OPC_Scope, 10,                             // 1599:       try {
  OPC_CheckField, 16, 4, 0,                  // 1601:        check Inst[19:16] == 0x0
  OPC_CheckPredicate, 10,                    // 1605:        check predicate 10
  OPC_Decode, 227, 7, 69,                    // 1607:        decode to MOVr using decoder 69
                                             // 1607:       } else try {
  OPC_CheckPredicate, 10,                    // 1611:        check predicate 10
  OPC_Decode, 228, 7, 70,                    // 1613:        decode to MOVr_TC using decoder 70
                                             // 1613:       }
                                             // 1613:      } else try {
  OPC_CheckPredicate, 10,                    // 1617:       check predicate 10
  OPC_CheckField, 16, 4, 0,                  // 1619:       check Inst[19:16] == 0x0
  OPC_Decode, 229, 7, 71,                    // 1623:       decode to MOVsi using decoder 71
                                             // 1623:      }
                                             // 1623:     }
  1, 0,                                      // 1627:     case 0x1: {
  OPC_Scope, 15,                             // 1629:      try {
  OPC_CheckField, 5, 7, 0,                   // 1631:       check Inst[11:5] == 0x0
  OPC_CheckPredicate, 10,                    // 1635:       check predicate 10
  OPC_SoftFail, 128, 128, 60, 0,             // 1637:       softfail pos=0x000f0000 neg=0x00000000
  OPC_Decode, 188, 14, 69,                   // 1642:       decode to MVNr using decoder 69
                                             // 1642:      } else try {
  OPC_CheckPredicate, 10,                    // 1646:       check predicate 10
  OPC_SoftFail, 128, 128, 60, 0,             // 1648:       softfail pos=0x000f0000 neg=0x00000000
  OPC_Decode, 189, 14, 71,                   // 1653:       decode to MVNsi using decoder 71
                                             // 1653:      }
                                             // 1653:     }
                                             // 1653:     } // switch Inst[22]
                                             // 1653:    }
                                             // 1653:    } // switch Inst[24:23]
                                             // 1653:   }
  1, 0,                                      // 1657:   case 0x1: {
  OPC_SwitchField, 7, 1,                     // 1659:    switch Inst[7] {
  0, 232, 1,                                 // 1662:    case 0x0: {
  OPC_SwitchField, 22, 3,                    // 1665:     switch Inst[24:22] {
  0, 6,                                      // 1668:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 1670:      check predicate 10
  OPC_Decode, 131, 7, 40,                    // 1672:      decode to EORrsr using decoder 40
                                             // 1672:     }
  1, 6,                                      // 1676:     case 0x1: {
  OPC_CheckPredicate, 10,                    // 1678:      check predicate 10
  OPC_Decode, 236, 14, 40,                   // 1680:      decode to RSBrsr using decoder 40
                                             // 1680:     }
  2, 6,                                      // 1684:     case 0x2: {
  OPC_CheckPredicate, 10,                    // 1686:      check predicate 10
  OPC_Decode, 164, 6, 41,                    // 1688:      decode to ADCrsr using decoder 41
                                             // 1688:     }
  3, 6,                                      // 1692:     case 0x3: {
  OPC_CheckPredicate, 10,                    // 1694:      check predicate 10
  OPC_Decode, 240, 14, 40,                   // 1696:      decode to RSCrsr using decoder 40
                                             // 1696:     }
  4, 107,                                    // 1700:     case 0x4: {
  OPC_SwitchField, 20, 1,                    // 1702:      switch Inst[20] {
  0, 89,                                     // 1705:      case 0x0: {
  OPC_SwitchField, 5, 2,                     // 1707:       switch Inst[6:5] {
  0, 35,                                     // 1710:       case 0x0: {
  OPC_CheckField, 8, 12, 255, 31,            // 1712:        check Inst[19:8] == 0xfff
  OPC_Scope, 10,                             // 1717:        try {
  OPC_CheckField, 0, 4, 14,                  // 1719:         check Inst[3:0] == 0xe
  OPC_CheckPredicate, 20,                    // 1723:         check predicate 20
  OPC_Decode, 199, 6, 67,                    // 1725:         decode to BX_RET using decoder 67
  OPC_Scope, 10,                             // 1729:        } else try {
  OPC_CheckField, 28, 4, 14,                 // 1731:         check Inst[31:28] == 0xe
  OPC_CheckPredicate, 20,                    // 1735:         check predicate 20
  OPC_Decode, 197, 6, 72,                    // 1737:         decode to BX using decoder 72
                                             // 1737:        } else try {
  OPC_CheckPredicate, 20,                    // 1741:         check predicate 20
  OPC_Decode, 200, 6, 66,                    // 1743:         decode to BX_pred using decoder 66
                                             // 1743:        }
                                             // 1743:       }
  1, 23,                                     // 1747:       case 0x1: {
  OPC_CheckField, 8, 12, 255, 31,            // 1749:        check Inst[19:8] == 0xfff
  OPC_Scope, 10,                             // 1754:        try {
  OPC_CheckField, 28, 4, 14,                 // 1756:         check Inst[31:28] == 0xe
  OPC_CheckPredicate, 21,                    // 1760:         check predicate 21
  OPC_Decode, 193, 6, 72,                    // 1762:         decode to BLX using decoder 72
                                             // 1762:        } else try {
  OPC_CheckPredicate, 21,                    // 1766:         check predicate 21
  OPC_Decode, 194, 6, 66,                    // 1768:         decode to BLX_pred using decoder 66
                                             // 1768:        }
                                             // 1768:       }
  2, 10,                                     // 1772:       case 0x2: {
  OPC_CheckPredicate, 10,                    // 1774:        check predicate 10
  OPC_SoftFail, 128, 30, 0,                  // 1776:        softfail pos=0x00000f00 neg=0x00000000
  OPC_Decode, 218, 14, 59,                   // 1780:        decode to QSUB using decoder 59
                                             // 1780:       }
  3, 0,                                      // 1784:       case 0x3: {
  OPC_CheckPredicate, 10,                    // 1786:        check predicate 10
  OPC_CheckField, 28, 4, 14,                 // 1788:        check Inst[31:28] == 0xe
  OPC_Decode, 191, 6, 53,                    // 1792:        decode to BKPT using decoder 53
                                             // 1792:       }
                                             // 1792:       } // switch Inst[6:5]
                                             // 1792:      }
  1, 0,                                      // 1796:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 1798:       check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              // 1800:       softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 139, 16, 56,                   // 1805:       decode to TEQrsr using decoder 56
                                             // 1805:      }
                                             // 1805:      } // switch Inst[20]
                                             // 1805:     }
  5, 61,                                     // 1809:     case 0x5: {
  OPC_SwitchField, 20, 1,                    // 1811:      switch Inst[20] {
  0, 43,                                     // 1814:      case 0x0: {
  OPC_SwitchField, 5, 2,                     // 1816:       switch Inst[6:5] {
  0, 14,                                     // 1819:       case 0x0: {
  OPC_CheckPredicate, 21,                    // 1821:        check predicate 21
  OPC_CheckField, 16, 4, 15,                 // 1823:        check Inst[19:16] == 0xf
  OPC_CheckField, 8, 4, 15,                  // 1827:        check Inst[11:8] == 0xf
  OPC_Decode, 235, 6, 73,                    // 1831:        decode to CLZ using decoder 73
                                             // 1831:       }
  2, 10,                                     // 1835:       case 0x2: {
  OPC_CheckPredicate, 10,                    // 1837:        check predicate 10
  OPC_SoftFail, 128, 30, 0,                  // 1839:        softfail pos=0x00000f00 neg=0x00000000
  OPC_Decode, 216, 14, 59,                   // 1843:        decode to QDSUB using decoder 59
                                             // 1843:       }
  3, 0,                                      // 1847:       case 0x3: {
  OPC_CheckPredicate, 22,                    // 1849:        check predicate 22
  OPC_CheckField, 8, 12, 0,                  // 1851:        check Inst[19:8] == 0x0
  OPC_Decode, 142, 15, 74,                   // 1855:        decode to SMC using decoder 74
                                             // 1855:       }
                                             // 1855:       } // switch Inst[6:5]
                                             // 1855:      }
  1, 0,                                      // 1859:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 1861:       check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              // 1863:       softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 239, 6, 56,                    // 1868:       decode to CMNzrsr using decoder 56
                                             // 1868:      }
                                             // 1868:      } // switch Inst[20]
                                             // 1868:     }
  6, 10,                                     // 1872:     case 0x6: {
  OPC_CheckPredicate, 10,                    // 1874:      check predicate 10
  OPC_CheckField, 16, 4, 0,                  // 1876:      check Inst[19:16] == 0x0
  OPC_Decode, 230, 7, 75,                    // 1880:      decode to MOVsr using decoder 75
                                             // 1880:     }
  7, 0,                                      // 1884:     case 0x7: {
  OPC_CheckPredicate, 10,                    // 1886:      check predicate 10
  OPC_SoftFail, 128, 128, 60, 0,             // 1888:      softfail pos=0x000f0000 neg=0x00000000
  OPC_Decode, 190, 14, 75,                   // 1893:      decode to MVNsr using decoder 75
                                             // 1893:     }
                                             // 1893:     } // switch Inst[24:22]
                                             // 1893:    }
  1, 0,                                      // 1897:    case 0x1: {
  OPC_SwitchField, 5, 2,                     // 1899:     switch Inst[6:5] {
  0, 178, 1,                                 // 1902:     case 0x0: {
  OPC_SwitchField, 22, 3,                    // 1905:      switch Inst[24:22] {
  0, 6,                                      // 1908:      case 0x0: {
  OPC_CheckPredicate, 11,                    // 1910:       check predicate 11
  OPC_Decode, 221, 7, 76,                    // 1912:       decode to MLA using decoder 76
                                             // 1912:      }
  1, 10,                                     // 1916:      case 0x1: {
  OPC_CheckPredicate, 23,                    // 1918:       check predicate 23
  OPC_CheckField, 20, 1, 0,                  // 1920:       check Inst[20] == 0x0
  OPC_Decode, 222, 7, 77,                    // 1924:       decode to MLS using decoder 77
                                             // 1924:      }
  2, 6,                                      // 1928:      case 0x2: {
  OPC_CheckPredicate, 11,                    // 1930:       check predicate 11
  OPC_Decode, 159, 16, 78,                   // 1932:       decode to UMLAL using decoder 78
                                             // 1932:      }
  3, 6,                                      // 1936:      case 0x3: {
  OPC_CheckPredicate, 11,                    // 1938:       check predicate 11
  OPC_Decode, 147, 15, 78,                   // 1940:       decode to SMLAL using decoder 78
                                             // 1940:      }
  6, 53,                                     // 1944:      case 0x6: {
  OPC_SwitchField, 8, 4,                     // 1946:       switch Inst[11:8] {
  14, 23,                                    // 1949:       case 0xe: {
  OPC_SwitchField, 20, 1,                    // 1951:        switch Inst[20] {
  0, 6,                                      // 1954:        case 0x0: {
  OPC_CheckPredicate, 19,                    // 1956:         check predicate 19
  OPC_Decode, 212, 15, 79,                   // 1958:         decode to STLEXD using decoder 79
                                             // 1958:        }
  1, 0,                                      // 1962:        case 0x1: {
  OPC_CheckPredicate, 19,                    // 1964:         check predicate 19
  OPC_CheckField, 0, 4, 15,                  // 1966:         check Inst[3:0] == 0xf
  OPC_Decode, 151, 7, 80,                    // 1970:         decode to LDAEXD using decoder 80
                                             // 1970:        }
                                             // 1970:        } // switch Inst[20]
                                             // 1970:       }
  15, 0,                                     // 1974:       case 0xf: {
  OPC_SwitchField, 20, 1,                    // 1976:        switch Inst[20] {
  0, 6,                                      // 1979:        case 0x0: {
  OPC_CheckPredicate, 10,                    // 1981:         check predicate 10
  OPC_Decode, 236, 15, 79,                   // 1983:         decode to STREXD using decoder 79
                                             // 1983:        }
  1, 0,                                      // 1987:        case 0x1: {
  OPC_CheckPredicate, 10,                    // 1989:         check predicate 10
  OPC_CheckField, 0, 4, 15,                  // 1991:         check Inst[3:0] == 0xf
  OPC_Decode, 191, 7, 80,                    // 1995:         decode to LDREXD using decoder 80
                                             // 1995:        }
                                             // 1995:        } // switch Inst[20]
                                             // 1995:       }
                                             // 1995:       } // switch Inst[11:8]
                                             // 1995:      }
  7, 0,                                      // 1999:      case 0x7: {
  OPC_SwitchField, 8, 4,                     // 2001:       switch Inst[11:8] {
  12, 27,                                    // 2004:       case 0xc: {
  OPC_SwitchField, 20, 1,                    // 2006:        switch Inst[20] {
  0, 10,                                     // 2009:        case 0x0: {
  OPC_CheckPredicate, 18,                    // 2011:         check predicate 18
  OPC_CheckField, 12, 4, 15,                 // 2013:         check Inst[15:12] == 0xf
  OPC_Decode, 214, 15, 60,                   // 2017:         decode to STLH using decoder 60
                                             // 2017:        }
  1, 0,                                      // 2021:        case 0x1: {
  OPC_CheckPredicate, 18,                    // 2023:         check predicate 18
  OPC_CheckField, 0, 4, 15,                  // 2025:         check Inst[3:0] == 0xf
  OPC_Decode, 153, 7, 61,                    // 2029:         decode to LDAH using decoder 61
                                             // 2029:        }
                                             // 2029:        } // switch Inst[20]
                                             // 2029:       }
  14, 23,                                    // 2033:       case 0xe: {
  OPC_SwitchField, 20, 1,                    // 2035:        switch Inst[20] {
  0, 6,                                      // 2038:        case 0x0: {
  OPC_CheckPredicate, 19,                    // 2040:         check predicate 19
  OPC_Decode, 213, 15, 62,                   // 2042:         decode to STLEXH using decoder 62
                                             // 2042:        }
  1, 0,                                      // 2046:        case 0x1: {
  OPC_CheckPredicate, 19,                    // 2048:         check predicate 19
  OPC_CheckField, 0, 4, 15,                  // 2050:         check Inst[3:0] == 0xf
  OPC_Decode, 152, 7, 61,                    // 2054:         decode to LDAEXH using decoder 61
                                             // 2054:        }
                                             // 2054:        } // switch Inst[20]
                                             // 2054:       }
  15, 0,                                     // 2058:       case 0xf: {
  OPC_SwitchField, 20, 1,                    // 2060:        switch Inst[20] {
  0, 6,                                      // 2063:        case 0x0: {
  OPC_CheckPredicate, 10,                    // 2065:         check predicate 10
  OPC_Decode, 237, 15, 62,                   // 2067:         decode to STREXH using decoder 62
                                             // 2067:        }
  1, 0,                                      // 2071:        case 0x1: {
  OPC_CheckPredicate, 10,                    // 2073:         check predicate 10
  OPC_CheckField, 0, 4, 15,                  // 2075:         check Inst[3:0] == 0xf
  OPC_Decode, 192, 7, 61,                    // 2079:         decode to LDREXH using decoder 61
                                             // 2079:        }
                                             // 2079:        } // switch Inst[20]
                                             // 2079:       }
                                             // 2079:       } // switch Inst[11:8]
                                             // 2079:      }
                                             // 2079:      } // switch Inst[24:22]
                                             // 2079:     }
  1, 79,                                     // 2083:     case 0x1: {
  OPC_SwitchField, 20, 1,                    // 2085:      switch Inst[20] {
  0, 36,                                     // 2088:      case 0x0: {
  OPC_SwitchField, 24, 1,                    // 2090:       switch Inst[24] {
  0, 23,                                     // 2093:       case 0x0: {
  OPC_SwitchField, 22, 1,                    // 2095:        switch Inst[22] {
  0, 10,                                     // 2098:        case 0x0: {
  OPC_CheckPredicate, 10,                    // 2100:         check predicate 10
  OPC_CheckField, 8, 4, 0,                   // 2102:         check Inst[11:8] == 0x0
  OPC_Decode, 240, 15, 81,                   // 2106:         decode to STRHTr using decoder 81
                                             // 2106:        }
  1, 0,                                      // 2110:        case 0x1: {
  OPC_CheckPredicate, 10,                    // 2112:         check predicate 10
  OPC_Decode, 239, 15, 82,                   // 2114:         decode to STRHTi using decoder 82
                                             // 2114:        }
                                             // 2114:        } // switch Inst[22]
                                             // 2114:       }
  1, 0,                                      // 2118:       case 0x1: {
  OPC_CheckPredicate, 10,                    // 2120:        check predicate 10
  OPC_Decode, 242, 15, 45,                   // 2122:        decode to STRH_PRE using decoder 45
                                             // 2122:       }
                                             // 2122:       } // switch Inst[24]
                                             // 2122:      }
  1, 0,                                      // 2126:      case 0x1: {
  OPC_SwitchField, 24, 1,                    // 2128:       switch Inst[24] {
  0, 23,                                     // 2131:       case 0x0: {
  OPC_SwitchField, 22, 1,                    // 2133:        switch Inst[22] {
  0, 10,                                     // 2136:        case 0x0: {
  OPC_CheckPredicate, 10,                    // 2138:         check predicate 10
  OPC_SoftFail, 128, 30, 0,                  // 2140:         softfail pos=0x00000f00 neg=0x00000000
  OPC_Decode, 195, 7, 83,                    // 2144:         decode to LDRHTr using decoder 83
                                             // 2144:        }
  1, 0,                                      // 2148:        case 0x1: {
  OPC_CheckPredicate, 10,                    // 2150:         check predicate 10
  OPC_Decode, 194, 7, 84,                    // 2152:         decode to LDRHTi using decoder 84
                                             // 2152:        }
                                             // 2152:        } // switch Inst[22]
                                             // 2152:       }
  1, 0,                                      // 2156:       case 0x1: {
  OPC_CheckPredicate, 10,                    // 2158:        check predicate 10
  OPC_Decode, 197, 7, 45,                    // 2160:        decode to LDRH_PRE using decoder 45
                                             // 2160:       }
                                             // 2160:       } // switch Inst[24]
                                             // 2160:      }
                                             // 2160:      } // switch Inst[20]
                                             // 2160:     }
  2, 53,                                     // 2164:     case 0x2: {
  OPC_SwitchField, 20, 1,                    // 2166:      switch Inst[20] {
  0, 10,                                     // 2169:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 2171:       check predicate 10
  OPC_CheckField, 24, 1, 1,                  // 2173:       check Inst[24] == 0x1
  OPC_Decode, 188, 7, 45,                    // 2177:       decode to LDRD_PRE using decoder 45
                                             // 2177:      }
  1, 0,                                      // 2181:      case 0x1: {
  OPC_SwitchField, 24, 1,                    // 2183:       switch Inst[24] {
  0, 23,                                     // 2186:       case 0x0: {
  OPC_SwitchField, 22, 1,                    // 2188:        switch Inst[22] {
  0, 10,                                     // 2191:        case 0x0: {
  OPC_CheckPredicate, 10,                    // 2193:         check predicate 10
  OPC_SoftFail, 128, 30, 0,                  // 2195:         softfail pos=0x00000f00 neg=0x00000000
  OPC_Decode, 200, 7, 83,                    // 2199:         decode to LDRSBTr using decoder 83
                                             // 2199:        }
  1, 0,                                      // 2203:        case 0x1: {
  OPC_CheckPredicate, 10,                    // 2205:         check predicate 10
  OPC_Decode, 199, 7, 84,                    // 2207:         decode to LDRSBTi using decoder 84
                                             // 2207:        }
                                             // 2207:        } // switch Inst[22]
                                             // 2207:       }
  1, 0,                                      // 2211:       case 0x1: {
  OPC_CheckPredicate, 10,                    // 2213:        check predicate 10
  OPC_Decode, 202, 7, 45,                    // 2215:        decode to LDRSB_PRE using decoder 45
                                             // 2215:       }
                                             // 2215:       } // switch Inst[24]
                                             // 2215:      }
                                             // 2215:      } // switch Inst[20]
                                             // 2215:     }
  3, 0,                                      // 2219:     case 0x3: {
  OPC_SwitchField, 20, 1,                    // 2221:      switch Inst[20] {
  0, 10,                                     // 2224:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 2226:       check predicate 10
  OPC_CheckField, 24, 1, 1,                  // 2228:       check Inst[24] == 0x1
  OPC_Decode, 233, 15, 45,                   // 2232:       decode to STRD_PRE using decoder 45
                                             // 2232:      }
  1, 0,                                      // 2236:      case 0x1: {
  OPC_SwitchField, 24, 1,                    // 2238:       switch Inst[24] {
  0, 23,                                     // 2241:       case 0x0: {
  OPC_SwitchField, 22, 1,                    // 2243:        switch Inst[22] {
  0, 10,                                     // 2246:        case 0x0: {
  OPC_CheckPredicate, 10,                    // 2248:         check predicate 10
  OPC_SoftFail, 128, 30, 0,                  // 2250:         softfail pos=0x00000f00 neg=0x00000000
  OPC_Decode, 205, 7, 83,                    // 2254:         decode to LDRSHTr using decoder 83
                                             // 2254:        }
  1, 0,                                      // 2258:        case 0x1: {
  OPC_CheckPredicate, 10,                    // 2260:         check predicate 10
  OPC_Decode, 204, 7, 84,                    // 2262:         decode to LDRSHTi using decoder 84
                                             // 2262:        }
                                             // 2262:        } // switch Inst[22]
                                             // 2262:       }
  1, 0,                                      // 2266:       case 0x1: {
  OPC_CheckPredicate, 10,                    // 2268:        check predicate 10
  OPC_Decode, 207, 7, 45,                    // 2270:        decode to LDRSH_PRE using decoder 45
                                             // 2270:       }
                                             // 2270:       } // switch Inst[24]
                                             // 2270:      }
                                             // 2270:      } // switch Inst[20]
                                             // 2270:     }
                                             // 2270:     } // switch Inst[6:5]
                                             // 2270:    }
                                             // 2270:    } // switch Inst[7]
                                             // 2270:   }
                                             // 2270:   } // switch Inst[4]
                                             // 2270:  }
                                             // 2270:  } // switch Inst[21]
                                             // 2270: }
  1, 190, 2,                                 // 2274: case 0x1: {
  OPC_SwitchField, 21, 1,                    // 2277:  switch Inst[21] {
  0, 125,                                    // 2280:  case 0x0: {
  OPC_SwitchField, 24, 1,                    // 2282:   switch Inst[24] {
  0, 47,                                     // 2285:   case 0x0: {
  OPC_Scope, 35,                             // 2287:    try {
  OPC_SwitchField, 22, 2,                    // 2289:     switch Inst[23:22] {
  0, 6,                                      // 2292:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 2294:      check predicate 10
  OPC_Decode, 174, 6, 85,                    // 2296:      decode to ANDri using decoder 85
                                             // 2296:     }
  1, 6,                                      // 2300:     case 0x1: {
  OPC_CheckPredicate, 10,                    // 2302:      check predicate 10
  OPC_Decode, 251, 15, 85,                   // 2304:      decode to SUBri using decoder 85
                                             // 2304:     }
  2, 6,                                      // 2308:     case 0x2: {
  OPC_CheckPredicate, 10,                    // 2310:      check predicate 10
  OPC_Decode, 165, 6, 85,                    // 2312:      decode to ADDri using decoder 85
                                             // 2312:     }
  3, 0,                                      // 2316:     case 0x3: {
  OPC_CheckPredicate, 10,                    // 2318:      check predicate 10
  OPC_Decode, 245, 14, 85,                   // 2320:      decode to SBCri using decoder 85
                                             // 2320:     }
                                             // 2320:     } // switch Inst[23:22]
                                             // 2320:    } else try {
  OPC_CheckPredicate, 10,                    // 2324:     check predicate 10
  OPC_CheckField, 16, 5, 15,                 // 2326:     check Inst[20:16] == 0xf
  OPC_Decode, 169, 6, 86,                    // 2330:     decode to ADR using decoder 86
                                             // 2330:    }
                                             // 2330:   }
  1, 0,                                      // 2334:   case 0x1: {
  OPC_SwitchField, 22, 2,                    // 2336:    switch Inst[23:22] {
  0, 24,                                     // 2339:    case 0x0: {
  OPC_SwitchField, 20, 1,                    // 2341:     switch Inst[20] {
  0, 6,                                      // 2344:     case 0x0: {
  OPC_CheckPredicate, 23,                    // 2346:      check predicate 23
  OPC_Decode, 226, 7, 87,                    // 2348:      decode to MOVi16 using decoder 87
                                             // 2348:     }
  1, 0,                                      // 2352:     case 0x1: {
  OPC_CheckPredicate, 10,                    // 2354:      check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              // 2356:      softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 142, 16, 88,                   // 2361:      decode to TSTri using decoder 88
                                             // 2361:     }
                                             // 2361:     } // switch Inst[20]
                                             // 2361:    }
  1, 24,                                     // 2365:    case 0x1: {
  OPC_SwitchField, 20, 1,                    // 2367:     switch Inst[20] {
  0, 6,                                      // 2370:     case 0x0: {
  OPC_CheckPredicate, 23,                    // 2372:      check predicate 23
  OPC_Decode, 224, 7, 87,                    // 2374:      decode to MOVTi16 using decoder 87
                                             // 2374:     }
  1, 0,                                      // 2378:     case 0x1: {
  OPC_CheckPredicate, 10,                    // 2380:      check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              // 2382:      softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 240, 6, 88,                    // 2387:      decode to CMPri using decoder 88
                                             // 2387:     }
                                             // 2387:     } // switch Inst[20]
                                             // 2387:    }
  2, 6,                                      // 2391:    case 0x2: {
  OPC_CheckPredicate, 10,                    // 2393:     check predicate 10
  OPC_Decode, 199, 14, 85,                   // 2395:     decode to ORRri using decoder 85
                                             // 2395:    }
  3, 0,                                      // 2399:    case 0x3: {
  OPC_CheckPredicate, 10,                    // 2401:     check predicate 10
  OPC_Decode, 187, 6, 85,                    // 2403:     decode to BICri using decoder 85
                                             // 2403:    }
                                             // 2403:    } // switch Inst[23:22]
                                             // 2403:   }
                                             // 2403:   } // switch Inst[24]
                                             // 2403:  }
  1, 0,                                      // 2407:  case 0x1: {
  OPC_SwitchField, 23, 2,                    // 2409:   switch Inst[24:23] {
  0, 19,                                     // 2412:   case 0x0: {
  OPC_SwitchField, 22, 1,                    // 2414:    switch Inst[22] {
  0, 6,                                      // 2417:    case 0x0: {
  OPC_CheckPredicate, 10,                    // 2419:     check predicate 10
  OPC_Decode, 128, 7, 85,                    // 2421:     decode to EORri using decoder 85
                                             // 2421:    }
  1, 0,                                      // 2425:    case 0x1: {
  OPC_CheckPredicate, 10,                    // 2427:     check predicate 10
  OPC_Decode, 233, 14, 85,                   // 2429:     decode to RSBri using decoder 85
                                             // 2429:    }
                                             // 2429:    } // switch Inst[22]
                                             // 2429:   }
  1, 19,                                     // 2433:   case 0x1: {
  OPC_SwitchField, 22, 1,                    // 2435:    switch Inst[22] {
  0, 6,                                      // 2438:    case 0x0: {
  OPC_CheckPredicate, 10,                    // 2440:     check predicate 10
  OPC_Decode, 161, 6, 85,                    // 2442:     decode to ADCri using decoder 85
                                             // 2442:    }
  1, 0,                                      // 2446:    case 0x1: {
  OPC_CheckPredicate, 10,                    // 2448:     check predicate 10
  OPC_Decode, 237, 14, 85,                   // 2450:     decode to RSCri using decoder 85
                                             // 2450:    }
                                             // 2450:    } // switch Inst[22]
                                             // 2450:   }
  2, 110,                                    // 2454:   case 0x2: {
  OPC_SwitchField, 20, 1,                    // 2456:    switch Inst[20] {
  0, 74,                                     // 2459:    case 0x0: {
  OPC_CheckField, 12, 4, 15,                 // 2461:     check Inst[15:12] == 0xf
  OPC_Scope, 22,                             // 2465:     try {
  OPC_CheckField, 0, 12, 18,                 // 2467:      check Inst[11:0] == 0x12
  OPC_CheckPredicate, 24,                    // 2471:      check predicate 24
  OPC_CheckField, 28, 4, 14,                 // 2473:      check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  // 2477:      check Inst[22] == 0x0
  OPC_CheckField, 16, 4, 0,                  // 2481:      check Inst[19:16] == 0x0
  OPC_Decode, 141, 16, 89,                   // 2485:      decode to TSB using decoder 89
  OPC_Scope, 18,                             // 2489:     } else try {
  OPC_CheckField, 4, 8, 15,                  // 2491:      check Inst[11:4] == 0xf
  OPC_CheckPredicate, 25,                    // 2495:      check predicate 25
  OPC_CheckField, 22, 1, 0,                  // 2497:      check Inst[22] == 0x0
  OPC_CheckField, 16, 4, 0,                  // 2501:      check Inst[19:16] == 0x0
  OPC_Decode, 253, 6, 74,                    // 2505:      decode to DBG using decoder 74
  OPC_Scope, 18,                             // 2509:     } else try {
  OPC_CheckField, 8, 4, 0,                   // 2511:      check Inst[11:8] == 0x0
  OPC_CheckPredicate, 11,                    // 2515:      check predicate 11
  OPC_CheckField, 22, 1, 0,                  // 2517:      check Inst[22] == 0x0
  OPC_CheckField, 16, 4, 0,                  // 2521:      check Inst[19:16] == 0x0
  OPC_Decode, 143, 7, 90,                    // 2525:      decode to HINT using decoder 90
                                             // 2525:     } else try {
  OPC_CheckPredicate, 10,                    // 2529:      check predicate 10
  OPC_Decode, 240, 7, 91,                    // 2531:      decode to MSRi using decoder 91
                                             // 2531:     }
                                             // 2531:    }
  1, 0,                                      // 2535:    case 0x1: {
  OPC_SwitchField, 22, 1,                    // 2537:     switch Inst[22] {
  0, 11,                                     // 2540:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 2542:      check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              // 2544:      softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 136, 16, 88,                   // 2549:      decode to TEQri using decoder 88
                                             // 2549:     }
  1, 0,                                      // 2553:     case 0x1: {
  OPC_CheckPredicate, 10,                    // 2555:      check predicate 10
  OPC_SoftFail, 128, 224, 3, 0,              // 2557:      softfail pos=0x0000f000 neg=0x00000000
  OPC_Decode, 236, 6, 88,                    // 2562:      decode to CMNri using decoder 88
                                             // 2562:     }
                                             // 2562:     } // switch Inst[22]
                                             // 2562:    }
                                             // 2562:    } // switch Inst[20]
                                             // 2562:   }
  3, 0,                                      // 2566:   case 0x3: {
  OPC_SwitchField, 22, 1,                    // 2568:    switch Inst[22] {
  0, 10,                                     // 2571:    case 0x0: {
  OPC_CheckPredicate, 10,                    // 2573:     check predicate 10
  OPC_CheckField, 16, 4, 0,                  // 2575:     check Inst[19:16] == 0x0
  OPC_Decode, 225, 7, 92,                    // 2579:     decode to MOVi using decoder 92
                                             // 2579:    }
  1, 0,                                      // 2583:    case 0x1: {
  OPC_CheckPredicate, 10,                    // 2585:     check predicate 10
  OPC_CheckField, 16, 4, 0,                  // 2587:     check Inst[19:16] == 0x0
  OPC_Decode, 187, 14, 92,                   // 2591:     decode to MVNi using decoder 92
                                             // 2591:    }
                                             // 2591:    } // switch Inst[22]
                                             // 2591:   }
                                             // 2591:   } // switch Inst[24:23]
                                             // 2591:  }
                                             // 2591:  } // switch Inst[21]
                                             // 2591: }
  2, 198, 2,                                 // 2595: case 0x2: {
  OPC_SwitchField, 20, 3,                    // 2598:  switch Inst[22:20] {
  0, 19,                                     // 2601:  case 0x0: {
  OPC_SwitchField, 24, 1,                    // 2603:   switch Inst[24] {
  0, 6,                                      // 2606:   case 0x0: {
  OPC_CheckPredicate, 10,                    // 2608:    check predicate 10
  OPC_Decode, 245, 15, 93,                   // 2610:    decode to STR_POST_IMM using decoder 93
                                             // 2610:   }
  1, 0,                                      // 2614:   case 0x1: {
  OPC_CheckPredicate, 10,                    // 2616:    check predicate 10
  OPC_Decode, 249, 15, 94,                   // 2618:    decode to STRi12 using decoder 94
                                             // 2618:   }
                                             // 2618:   } // switch Inst[24]
                                             // 2618:  }
  1, 35,                                     // 2622:  case 0x1: {
  OPC_SwitchField, 24, 1,                    // 2624:   switch Inst[24] {
  0, 6,                                      // 2627:   case 0x0: {
  OPC_CheckPredicate, 10,                    // 2629:    check predicate 10
  OPC_Decode, 210, 7, 93,                    // 2631:    decode to LDR_POST_IMM using decoder 93
                                             // 2631:   }
  1, 0,                                      // 2635:   case 0x1: {
  OPC_Scope, 14,                             // 2637:    try {
  OPC_CheckField, 12, 4, 15,                 // 2639:     check Inst[15:12] == 0xf
  OPC_CheckPredicate, 26,                    // 2643:     check predicate 26
  OPC_CheckField, 28, 4, 15,                 // 2645:     check Inst[31:28] == 0xf
  OPC_Decode, 205, 14, 95,                   // 2649:     decode to PLDWi12 using decoder 95
                                             // 2649:    } else try {
  OPC_CheckPredicate, 10,                    // 2653:     check predicate 10
  OPC_Decode, 215, 7, 94,                    // 2655:     decode to LDRi12 using decoder 94
                                             // 2655:    }
                                             // 2655:   }
                                             // 2655:   } // switch Inst[24]
                                             // 2655:  }
  2, 19,                                     // 2659:  case 0x2: {
  OPC_SwitchField, 24, 1,                    // 2661:   switch Inst[24] {
  0, 6,                                      // 2664:   case 0x0: {
  OPC_CheckPredicate, 10,                    // 2666:    check predicate 10
  OPC_Decode, 243, 15, 93,                   // 2668:    decode to STRT_POST_IMM using decoder 93
                                             // 2668:   }
  1, 0,                                      // 2672:   case 0x1: {
  OPC_CheckPredicate, 10,                    // 2674:    check predicate 10
  OPC_Decode, 247, 15, 96,                   // 2676:    decode to STR_PRE_IMM using decoder 96
                                             // 2676:   }
                                             // 2676:   } // switch Inst[24]
                                             // 2676:  }
  3, 19,                                     // 2680:  case 0x3: {
  OPC_SwitchField, 24, 1,                    // 2682:   switch Inst[24] {
  0, 6,                                      // 2685:   case 0x0: {
  OPC_CheckPredicate, 10,                    // 2687:    check predicate 10
  OPC_Decode, 208, 7, 93,                    // 2689:    decode to LDRT_POST_IMM using decoder 93
                                             // 2689:   }
  1, 0,                                      // 2693:   case 0x1: {
  OPC_CheckPredicate, 10,                    // 2695:    check predicate 10
  OPC_Decode, 212, 7, 97,                    // 2697:    decode to LDR_PRE_IMM using decoder 97
                                             // 2697:   }
                                             // 2697:   } // switch Inst[24]
                                             // 2697:  }
  4, 19,                                     // 2701:  case 0x4: {
  OPC_SwitchField, 24, 1,                    // 2703:   switch Inst[24] {
  0, 6,                                      // 2706:   case 0x0: {
  OPC_CheckPredicate, 10,                    // 2708:    check predicate 10
  OPC_Decode, 225, 15, 93,                   // 2710:    decode to STRB_POST_IMM using decoder 93
                                             // 2710:   }
  1, 0,                                      // 2714:   case 0x1: {
  OPC_CheckPredicate, 10,                    // 2716:    check predicate 10
  OPC_Decode, 229, 15, 98,                   // 2718:    decode to STRBi12 using decoder 98
                                             // 2718:   }
                                             // 2718:   } // switch Inst[24]
                                             // 2718:  }
  5, 51,                                     // 2722:  case 0x5: {
  OPC_SwitchField, 24, 1,                    // 2724:   switch Inst[24] {
  0, 22,                                     // 2727:   case 0x0: {
  OPC_Scope, 14,                             // 2729:    try {
  OPC_CheckField, 12, 4, 15,                 // 2731:     check Inst[15:12] == 0xf
  OPC_CheckPredicate, 25,                    // 2735:     check predicate 25
  OPC_CheckField, 28, 4, 15,                 // 2737:     check Inst[31:28] == 0xf
  OPC_Decode, 209, 14, 95,                   // 2741:     decode to PLIi12 using decoder 95
                                             // 2741:    } else try {
  OPC_CheckPredicate, 10,                    // 2745:     check predicate 10
  OPC_Decode, 180, 7, 93,                    // 2747:     decode to LDRB_POST_IMM using decoder 93
                                             // 2747:    }
                                             // 2747:   }
  1, 0,                                      // 2751:   case 0x1: {
  OPC_Scope, 14,                             // 2753:    try {
  OPC_CheckField, 12, 4, 15,                 // 2755:     check Inst[15:12] == 0xf
  OPC_CheckPredicate, 10,                    // 2759:     check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 2761:     check Inst[31:28] == 0xf
  OPC_Decode, 207, 14, 95,                   // 2765:     decode to PLDi12 using decoder 95
                                             // 2765:    } else try {
  OPC_CheckPredicate, 10,                    // 2769:     check predicate 10
  OPC_Decode, 184, 7, 98,                    // 2771:     decode to LDRBi12 using decoder 98
                                             // 2771:    }
                                             // 2771:   }
                                             // 2771:   } // switch Inst[24]
                                             // 2771:  }
  6, 19,                                     // 2775:  case 0x6: {
  OPC_SwitchField, 24, 1,                    // 2777:   switch Inst[24] {
  0, 6,                                      // 2780:   case 0x0: {
  OPC_CheckPredicate, 10,                    // 2782:    check predicate 10
  OPC_Decode, 223, 15, 93,                   // 2784:    decode to STRBT_POST_IMM using decoder 93
                                             // 2784:   }
  1, 0,                                      // 2788:   case 0x1: {
  OPC_CheckPredicate, 10,                    // 2790:    check predicate 10
  OPC_Decode, 227, 15, 96,                   // 2792:    decode to STRB_PRE_IMM using decoder 96
                                             // 2792:   }
                                             // 2792:   } // switch Inst[24]
                                             // 2792:  }
  7, 0,                                      // 2796:  case 0x7: {
  OPC_SwitchField, 24, 1,                    // 2798:   switch Inst[24] {
  0, 6,                                      // 2801:   case 0x0: {
  OPC_CheckPredicate, 10,                    // 2803:    check predicate 10
  OPC_Decode, 178, 7, 93,                    // 2805:    decode to LDRBT_POST_IMM using decoder 93
                                             // 2805:   }
  1, 0,                                      // 2809:   case 0x1: {
  OPC_Scope, 20,                             // 2811:    try {
  OPC_CheckField, 0, 20, 159, 224, 63,       // 2813:     check Inst[19:0] == 0xff01f
  OPC_CheckPredicate, 27,                    // 2819:     check predicate 27
  OPC_CheckField, 28, 4, 15,                 // 2821:     check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 0,                  // 2825:     check Inst[23] == 0x0
  OPC_Decode, 234, 6, 25,                    // 2829:     decode to CLREX using decoder 25
  OPC_Scope, 57,                             // 2833:    } else try {
  OPC_SwitchField, 4, 16,                    // 2835:     switch Inst[19:4] {
  132, 254, 3, 14,                           // 2838:     case 0xff04: {
  OPC_CheckPredicate, 28,                    // 2842:      check predicate 28
  OPC_CheckField, 28, 4, 15,                 // 2844:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 0,                  // 2848:      check Inst[23] == 0x0
  OPC_Decode, 255, 6, 99,                    // 2852:      decode to DSB using decoder 99
                                             // 2852:     }
  133, 254, 3, 14,                           // 2856:     case 0xff05: {
  OPC_CheckPredicate, 28,                    // 2860:      check predicate 28
  OPC_CheckField, 28, 4, 15,                 // 2862:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 0,                  // 2866:      check Inst[23] == 0x0
  OPC_Decode, 254, 6, 99,                    // 2870:      decode to DMB using decoder 99
                                             // 2870:     }
  134, 254, 3, 0,                            // 2874:     case 0xff06: {
  OPC_CheckPredicate, 28,                    // 2878:      check predicate 28
  OPC_CheckField, 28, 4, 15,                 // 2880:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 0,                  // 2884:      check Inst[23] == 0x0
  OPC_Decode, 146, 7, 100,                   // 2888:      decode to ISB using decoder 100
                                             // 2888:     }
                                             // 2888:     } // switch Inst[19:4]
  OPC_Scope, 24,                             // 2892:    } else try {
  OPC_CheckField, 4, 4, 7,                   // 2894:     check Inst[7:4] == 0x7
  OPC_CheckPredicate, 29,                    // 2898:     check predicate 29
  OPC_CheckField, 28, 4, 15,                 // 2900:     check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 0,                  // 2904:     check Inst[23] == 0x0
  OPC_SoftFail, 143, 30, 128, 224, 63,       // 2908:     softfail pos=0x00000f0f neg=0x000ff000
  OPC_Decode, 244, 14, 25,                   // 2914:     decode to SB using decoder 25
                                             // 2914:    } else try {
  OPC_CheckPredicate, 10,                    // 2918:     check predicate 10
  OPC_Decode, 182, 7, 97,                    // 2920:     decode to LDRB_PRE_IMM using decoder 97
                                             // 2920:    }
                                             // 2920:   }
                                             // 2920:   } // switch Inst[24]
                                             // 2920:  }
                                             // 2920:  } // switch Inst[22:20]
                                             // 2920: }
  3, 145, 13,                                // 2924: case 0x3: {
  OPC_SwitchField, 21, 2,                    // 2927:  switch Inst[22:21] {
  0, 186, 3,                                 // 2930:  case 0x0: {
  OPC_SwitchField, 4, 1,                     // 2933:   switch Inst[4] {
  0, 61,                                     // 2936:   case 0x0: {
  OPC_SwitchField, 20, 1,                    // 2938:    switch Inst[20] {
  0, 19,                                     // 2941:    case 0x0: {
  OPC_SwitchField, 24, 1,                    // 2943:     switch Inst[24] {
  0, 6,                                      // 2946:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 2948:      check predicate 10
  OPC_Decode, 246, 15, 93,                   // 2950:      decode to STR_POST_REG using decoder 93
                                             // 2950:     }
  1, 0,                                      // 2954:     case 0x1: {
  OPC_CheckPredicate, 10,                    // 2956:      check predicate 10
  OPC_Decode, 250, 15, 101,                  // 2958:      decode to STRrs using decoder 101
                                             // 2958:     }
                                             // 2958:     } // switch Inst[24]
                                             // 2958:    }
  1, 0,                                      // 2962:    case 0x1: {
  OPC_SwitchField, 24, 1,                    // 2964:     switch Inst[24] {
  0, 6,                                      // 2967:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 2969:      check predicate 10
  OPC_Decode, 211, 7, 93,                    // 2971:      decode to LDR_POST_REG using decoder 93
                                             // 2971:     }
  1, 0,                                      // 2975:     case 0x1: {
  OPC_Scope, 14,                             // 2977:      try {
  OPC_CheckField, 12, 4, 15,                 // 2979:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 26,                    // 2983:       check predicate 26
  OPC_CheckField, 28, 4, 15,                 // 2985:       check Inst[31:28] == 0xf
  OPC_Decode, 206, 14, 102,                  // 2989:       decode to PLDWrs using decoder 102
                                             // 2989:      } else try {
  OPC_CheckPredicate, 10,                    // 2993:       check predicate 10
  OPC_Decode, 216, 7, 101,                   // 2995:       decode to LDRrs using decoder 101
                                             // 2995:      }
                                             // 2995:     }
                                             // 2995:     } // switch Inst[24]
                                             // 2995:    }
                                             // 2995:    } // switch Inst[20]
                                             // 2995:   }
  1, 0,                                      // 2999:   case 0x1: {
  OPC_SwitchField, 5, 2,                     // 3001:    switch Inst[6:5] {
  0, 125,                                    // 3004:    case 0x0: {
  OPC_SwitchField, 23, 2,                    // 3006:     switch Inst[24:23] {
  0, 35,                                     // 3009:     case 0x0: {
  OPC_SwitchField, 7, 1,                     // 3011:      switch Inst[7] {
  0, 14,                                     // 3014:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 3016:       check predicate 10
  OPC_CheckField, 20, 1, 1,                  // 3018:       check Inst[20] == 0x1
  OPC_SoftFail, 0, 128, 30,                  // 3022:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 241, 14, 103,                  // 3026:       decode to SADD16 using decoder 103
                                             // 3026:      }
  1, 0,                                      // 3030:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 3032:       check predicate 10
  OPC_CheckField, 20, 1, 1,                  // 3034:       check Inst[20] == 0x1
  OPC_SoftFail, 0, 128, 30,                  // 3038:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 242, 14, 103,                  // 3042:       decode to SADD8 using decoder 103
                                             // 3042:      }
                                             // 3042:      } // switch Inst[7]
                                             // 3042:     }
  1, 10,                                     // 3046:     case 0x1: {
  OPC_CheckPredicate, 11,                    // 3048:      check predicate 11
  OPC_CheckField, 20, 1, 0,                  // 3050:      check Inst[20] == 0x0
  OPC_Decode, 203, 14, 104,                  // 3054:      decode to PKHBT using decoder 104
                                             // 3054:     }
  2, 43,                                     // 3058:     case 0x2: {
  OPC_SwitchField, 20, 1,                    // 3060:      switch Inst[20] {
  0, 22,                                     // 3063:      case 0x0: {
  OPC_CheckField, 7, 1, 0,                   // 3065:       check Inst[7] == 0x0
  OPC_Scope, 10,                             // 3069:       try {
  OPC_CheckField, 12, 4, 15,                 // 3071:        check Inst[15:12] == 0xf
  OPC_CheckPredicate, 11,                    // 3075:        check predicate 11
  OPC_Decode, 168, 15, 105,                  // 3077:        decode to SMUAD using decoder 105
                                             // 3077:       } else try {
  OPC_CheckPredicate, 11,                    // 3081:        check predicate 11
  OPC_Decode, 145, 15, 106,                  // 3083:        decode to SMLAD using decoder 106
                                             // 3083:       }
                                             // 3083:      }
  1, 0,                                      // 3087:      case 0x1: {
  OPC_CheckPredicate, 30,                    // 3089:       check predicate 30
  OPC_CheckField, 12, 4, 15,                 // 3091:       check Inst[15:12] == 0xf
  OPC_CheckField, 7, 1, 0,                   // 3095:       check Inst[7] == 0x0
  OPC_Decode, 250, 14, 68,                   // 3099:       decode to SDIV using decoder 68
                                             // 3099:      }
                                             // 3099:      } // switch Inst[20]
                                             // 3099:     }
  3, 0,                                      // 3103:     case 0x3: {
  OPC_CheckField, 7, 1, 0,                   // 3105:      check Inst[7] == 0x0
  OPC_CheckField, 20, 1, 0,                  // 3109:      check Inst[20] == 0x0
  OPC_Scope, 10,                             // 3113:      try {
  OPC_CheckField, 12, 4, 15,                 // 3115:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 11,                    // 3119:       check predicate 11
  OPC_Decode, 167, 16, 68,                   // 3121:       decode to USAD8 using decoder 68
                                             // 3121:      } else try {
  OPC_CheckPredicate, 11,                    // 3125:       check predicate 11
  OPC_Decode, 168, 16, 77,                   // 3127:       decode to USADA8 using decoder 77
                                             // 3127:      }
                                             // 3127:     }
                                             // 3127:     } // switch Inst[24:23]
                                             // 3127:    }
  1, 71,                                     // 3131:    case 0x1: {
  OPC_SwitchField, 23, 2,                    // 3133:     switch Inst[24:23] {
  0, 18,                                     // 3136:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 3138:      check predicate 10
  OPC_CheckField, 20, 1, 1,                  // 3140:      check Inst[20] == 0x1
  OPC_CheckField, 7, 1, 0,                   // 3144:      check Inst[7] == 0x0
  OPC_SoftFail, 0, 128, 30,                  // 3148:      softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 243, 14, 103,                  // 3152:      decode to SASX using decoder 103
                                             // 3152:     }
  1, 18,                                     // 3156:     case 0x1: {
  OPC_CheckPredicate, 11,                    // 3158:      check predicate 11
  OPC_CheckField, 20, 1, 0,                  // 3160:      check Inst[20] == 0x0
  OPC_CheckField, 7, 1, 1,                   // 3164:      check Inst[7] == 0x1
  OPC_SoftFail, 0, 128, 30,                  // 3168:      softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 251, 14, 107,                  // 3172:      decode to SEL using decoder 107
                                             // 3172:     }
  2, 0,                                      // 3176:     case 0x2: {
  OPC_CheckField, 7, 1, 0,                   // 3178:      check Inst[7] == 0x0
  OPC_CheckField, 20, 1, 0,                  // 3182:      check Inst[20] == 0x0
  OPC_Scope, 10,                             // 3186:      try {
  OPC_CheckField, 12, 4, 15,                 // 3188:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 11,                    // 3192:       check predicate 11
  OPC_Decode, 169, 15, 105,                  // 3194:       decode to SMUADX using decoder 105
                                             // 3194:      } else try {
  OPC_CheckPredicate, 11,                    // 3198:       check predicate 11
  OPC_Decode, 146, 15, 106,                  // 3200:       decode to SMLADX using decoder 106
                                             // 3200:      }
                                             // 3200:     }
                                             // 3200:     } // switch Inst[24:23]
                                             // 3200:    }
  2, 63,                                     // 3204:    case 0x2: {
  OPC_SwitchField, 23, 2,                    // 3206:     switch Inst[24:23] {
  0, 18,                                     // 3209:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 3211:      check predicate 10
  OPC_CheckField, 20, 1, 1,                  // 3213:      check Inst[20] == 0x1
  OPC_CheckField, 7, 1, 0,                   // 3217:      check Inst[7] == 0x0
  OPC_SoftFail, 0, 128, 30,                  // 3221:      softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 189, 15, 103,                  // 3225:      decode to SSAX using decoder 103
                                             // 3225:     }
  1, 10,                                     // 3229:     case 0x1: {
  OPC_CheckPredicate, 11,                    // 3231:      check predicate 11
  OPC_CheckField, 20, 1, 0,                  // 3233:      check Inst[20] == 0x0
  OPC_Decode, 204, 14, 104,                  // 3237:      decode to PKHTB using decoder 104
                                             // 3237:     }
  2, 0,                                      // 3241:     case 0x2: {
  OPC_CheckField, 7, 1, 0,                   // 3243:      check Inst[7] == 0x0
  OPC_CheckField, 20, 1, 0,                  // 3247:      check Inst[20] == 0x0
  OPC_Scope, 10,                             // 3251:      try {
  OPC_CheckField, 12, 4, 15,                 // 3253:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 11,                    // 3257:       check predicate 11
  OPC_Decode, 177, 15, 105,                  // 3259:       decode to SMUSD using decoder 105
                                             // 3259:      } else try {
  OPC_CheckPredicate, 11,                    // 3263:       check predicate 11
  OPC_Decode, 158, 15, 106,                  // 3265:       decode to SMLSD using decoder 106
                                             // 3265:      }
                                             // 3265:     }
                                             // 3265:     } // switch Inst[24:23]
                                             // 3265:    }
  3, 0,                                      // 3269:    case 0x3: {
  OPC_SwitchField, 23, 2,                    // 3271:     switch Inst[24:23] {
  0, 35,                                     // 3274:     case 0x0: {
  OPC_SwitchField, 7, 1,                     // 3276:      switch Inst[7] {
  0, 14,                                     // 3279:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 3281:       check predicate 10
  OPC_CheckField, 20, 1, 1,                  // 3283:       check Inst[20] == 0x1
  OPC_SoftFail, 0, 128, 30,                  // 3287:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 190, 15, 103,                  // 3291:       decode to SSUB16 using decoder 103
                                             // 3291:      }
  1, 0,                                      // 3295:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 3297:       check predicate 10
  OPC_CheckField, 20, 1, 1,                  // 3299:       check Inst[20] == 0x1
  OPC_SoftFail, 0, 128, 30,                  // 3303:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 191, 15, 103,                  // 3307:       decode to SSUB8 using decoder 103
                                             // 3307:      }
                                             // 3307:      } // switch Inst[7]
                                             // 3307:     }
  1, 34,                                     // 3311:     case 0x1: {
  OPC_CheckField, 7, 1, 0,                   // 3313:      check Inst[7] == 0x0
  OPC_CheckField, 20, 1, 0,                  // 3317:      check Inst[20] == 0x0
  OPC_Scope, 14,                             // 3321:      try {
  OPC_CheckField, 16, 4, 15,                 // 3323:       check Inst[19:16] == 0xf
  OPC_CheckPredicate, 11,                    // 3327:       check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 3329:       softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 134, 16, 108,                  // 3333:       decode to SXTB16 using decoder 108
                                             // 3333:      } else try {
  OPC_CheckPredicate, 11,                    // 3337:       check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 3339:       softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 131, 16, 109,                  // 3343:       decode to SXTAB16 using decoder 109
                                             // 3343:      }
                                             // 3343:     }
  2, 0,                                      // 3347:     case 0x2: {
  OPC_CheckField, 7, 1, 0,                   // 3349:      check Inst[7] == 0x0
  OPC_CheckField, 20, 1, 0,                  // 3353:      check Inst[20] == 0x0
  OPC_Scope, 10,                             // 3357:      try {
  OPC_CheckField, 12, 4, 15,                 // 3359:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 11,                    // 3363:       check predicate 11
  OPC_Decode, 178, 15, 105,                  // 3365:       decode to SMUSDX using decoder 105
                                             // 3365:      } else try {
  OPC_CheckPredicate, 11,                    // 3369:       check predicate 11
  OPC_Decode, 159, 15, 106,                  // 3371:       decode to SMLSDX using decoder 106
                                             // 3371:      }
                                             // 3371:     }
                                             // 3371:     } // switch Inst[24:23]
                                             // 3371:    }
                                             // 3371:    } // switch Inst[6:5]
                                             // 3371:   }
                                             // 3371:   } // switch Inst[4]
                                             // 3371:  }
  1, 139, 3,                                 // 3375:  case 0x1: {
  OPC_SwitchField, 4, 1,                     // 3378:   switch Inst[4] {
  0, 45,                                     // 3381:   case 0x0: {
  OPC_SwitchField, 20, 1,                    // 3383:    switch Inst[20] {
  0, 19,                                     // 3386:    case 0x0: {
  OPC_SwitchField, 24, 1,                    // 3388:     switch Inst[24] {
  0, 6,                                      // 3391:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 3393:      check predicate 10
  OPC_Decode, 244, 15, 93,                   // 3395:      decode to STRT_POST_REG using decoder 93
                                             // 3395:     }
  1, 0,                                      // 3399:     case 0x1: {
  OPC_CheckPredicate, 10,                    // 3401:      check predicate 10
  OPC_Decode, 248, 15, 110,                  // 3403:      decode to STR_PRE_REG using decoder 110
                                             // 3403:     }
                                             // 3403:     } // switch Inst[24]
                                             // 3403:    }
  1, 0,                                      // 3407:    case 0x1: {
  OPC_SwitchField, 24, 1,                    // 3409:     switch Inst[24] {
  0, 6,                                      // 3412:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 3414:      check predicate 10
  OPC_Decode, 209, 7, 93,                    // 3416:      decode to LDRT_POST_REG using decoder 93
                                             // 3416:     }
  1, 0,                                      // 3420:     case 0x1: {
  OPC_CheckPredicate, 10,                    // 3422:      check predicate 10
  OPC_Decode, 213, 7, 111,                   // 3424:      decode to LDR_PRE_REG using decoder 111
                                             // 3424:     }
                                             // 3424:     } // switch Inst[24]
                                             // 3424:    }
                                             // 3424:    } // switch Inst[20]
                                             // 3424:   }
  1, 0,                                      // 3428:   case 0x1: {
  OPC_SwitchField, 23, 2,                    // 3430:    switch Inst[24:23] {
  0, 177, 1,                                 // 3433:    case 0x0: {
  OPC_SwitchField, 5, 3,                     // 3436:     switch Inst[7:5] {
  0, 27,                                     // 3439:     case 0x0: {
  OPC_SwitchField, 20, 1,                    // 3441:      switch Inst[20] {
  0, 10,                                     // 3444:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 3446:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3448:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 212, 14, 103,                  // 3452:       decode to QADD16 using decoder 103
                                             // 3452:      }
  1, 0,                                      // 3456:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 3458:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3460:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 136, 15, 103,                  // 3464:       decode to SHADD16 using decoder 103
                                             // 3464:      }
                                             // 3464:      } // switch Inst[20]
                                             // 3464:     }
  1, 27,                                     // 3468:     case 0x1: {
  OPC_SwitchField, 20, 1,                    // 3470:      switch Inst[20] {
  0, 10,                                     // 3473:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 3475:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3477:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 214, 14, 103,                  // 3481:       decode to QASX using decoder 103
                                             // 3481:      }
  1, 0,                                      // 3485:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 3487:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3489:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 138, 15, 103,                  // 3493:       decode to SHASX using decoder 103
                                             // 3493:      }
                                             // 3493:      } // switch Inst[20]
                                             // 3493:     }
  2, 27,                                     // 3497:     case 0x2: {
  OPC_SwitchField, 20, 1,                    // 3499:      switch Inst[20] {
  0, 10,                                     // 3502:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 3504:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3506:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 217, 14, 103,                  // 3510:       decode to QSAX using decoder 103
                                             // 3510:      }
  1, 0,                                      // 3514:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 3516:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3518:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 139, 15, 103,                  // 3522:       decode to SHSAX using decoder 103
                                             // 3522:      }
                                             // 3522:      } // switch Inst[20]
                                             // 3522:     }
  3, 27,                                     // 3526:     case 0x3: {
  OPC_SwitchField, 20, 1,                    // 3528:      switch Inst[20] {
  0, 10,                                     // 3531:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 3533:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3535:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 219, 14, 103,                  // 3539:       decode to QSUB16 using decoder 103
                                             // 3539:      }
  1, 0,                                      // 3543:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 3545:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3547:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 140, 15, 103,                  // 3551:       decode to SHSUB16 using decoder 103
                                             // 3551:      }
                                             // 3551:      } // switch Inst[20]
                                             // 3551:     }
  4, 27,                                     // 3555:     case 0x4: {
  OPC_SwitchField, 20, 1,                    // 3557:      switch Inst[20] {
  0, 10,                                     // 3560:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 3562:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3564:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 213, 14, 103,                  // 3568:       decode to QADD8 using decoder 103
                                             // 3568:      }
  1, 0,                                      // 3572:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 3574:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3576:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 137, 15, 103,                  // 3580:       decode to SHADD8 using decoder 103
                                             // 3580:      }
                                             // 3580:      } // switch Inst[20]
                                             // 3580:     }
  7, 0,                                      // 3584:     case 0x7: {
  OPC_SwitchField, 20, 1,                    // 3586:      switch Inst[20] {
  0, 10,                                     // 3589:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 3591:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3593:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 220, 14, 103,                  // 3597:       decode to QSUB8 using decoder 103
                                             // 3597:      }
  1, 0,                                      // 3601:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 3603:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 3605:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 141, 15, 103,                  // 3609:       decode to SHSUB8 using decoder 103
                                             // 3609:      }
                                             // 3609:      } // switch Inst[20]
                                             // 3609:     }
                                             // 3609:     } // switch Inst[7:5]
                                             // 3609:    }
  1, 126,                                    // 3613:    case 0x1: {
  OPC_SwitchField, 5, 1,                     // 3615:     switch Inst[5] {
  0, 6,                                      // 3618:     case 0x0: {
  OPC_CheckPredicate, 11,                    // 3620:      check predicate 11
  OPC_Decode, 187, 15, 112,                  // 3622:      decode to SSAT using decoder 112
                                             // 3622:     }
  1, 0,                                      // 3626:     case 0x1: {
  OPC_SwitchField, 6, 2,                     // 3628:      switch Inst[7:6] {
  0, 31,                                     // 3631:      case 0x0: {
  OPC_SwitchField, 20, 1,                    // 3633:       switch Inst[20] {
  0, 10,                                     // 3636:       case 0x0: {
  OPC_CheckPredicate, 11,                    // 3638:        check predicate 11
  OPC_CheckField, 8, 4, 15,                  // 3640:        check Inst[11:8] == 0xf
  OPC_Decode, 188, 15, 113,                  // 3644:        decode to SSAT16 using decoder 113
                                             // 3644:       }
  1, 0,                                      // 3648:       case 0x1: {
  OPC_CheckPredicate, 11,                    // 3650:        check predicate 11
  OPC_CheckField, 16, 4, 15,                 // 3652:        check Inst[19:16] == 0xf
  OPC_CheckField, 8, 4, 15,                  // 3656:        check Inst[11:8] == 0xf
  OPC_Decode, 222, 14, 73,                   // 3660:        decode to REV using decoder 73
                                             // 3660:       }
                                             // 3660:       } // switch Inst[20]
                                             // 3660:      }
  1, 59,                                     // 3664:      case 0x1: {
  OPC_SwitchField, 20, 1,                    // 3666:       switch Inst[20] {
  0, 26,                                     // 3669:       case 0x0: {
  OPC_Scope, 14,                             // 3671:        try {
  OPC_CheckField, 16, 4, 15,                 // 3673:         check Inst[19:16] == 0xf
  OPC_CheckPredicate, 11,                    // 3677:         check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 3679:         softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 133, 16, 108,                  // 3683:         decode to SXTB using decoder 108
                                             // 3683:        } else try {
  OPC_CheckPredicate, 11,                    // 3687:         check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 3689:         softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 130, 16, 109,                  // 3693:         decode to SXTAB using decoder 109
                                             // 3693:        }
                                             // 3693:       }
  1, 0,                                      // 3697:       case 0x1: {
  OPC_Scope, 14,                             // 3699:        try {
  OPC_CheckField, 16, 4, 15,                 // 3701:         check Inst[19:16] == 0xf
  OPC_CheckPredicate, 11,                    // 3705:         check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 3707:         softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 135, 16, 108,                  // 3711:         decode to SXTH using decoder 108
                                             // 3711:        } else try {
  OPC_CheckPredicate, 11,                    // 3715:         check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 3717:         softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 132, 16, 109,                  // 3721:         decode to SXTAH using decoder 109
                                             // 3721:        }
                                             // 3721:       }
                                             // 3721:       } // switch Inst[20]
                                             // 3721:      }
  2, 0,                                      // 3725:      case 0x2: {
  OPC_CheckPredicate, 11,                    // 3727:       check predicate 11
  OPC_CheckField, 16, 5, 31,                 // 3729:       check Inst[20:16] == 0x1f
  OPC_CheckField, 8, 4, 15,                  // 3733:       check Inst[11:8] == 0xf
  OPC_Decode, 223, 14, 73,                   // 3737:       decode to REV16 using decoder 73
                                             // 3737:      }
                                             // 3737:      } // switch Inst[7:6]
                                             // 3737:     }
                                             // 3737:     } // switch Inst[5]
                                             // 3737:    }
  2, 18,                                     // 3741:    case 0x2: {
  OPC_CheckPredicate, 30,                    // 3743:     check predicate 30
  OPC_CheckField, 20, 1, 1,                  // 3745:     check Inst[20] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3749:     check Inst[15:12] == 0xf
  OPC_CheckField, 5, 3, 0,                   // 3753:     check Inst[7:5] == 0x0
  OPC_Decode, 151, 16, 68,                   // 3757:     decode to UDIV using decoder 68
                                             // 3757:    }
  3, 0,                                      // 3761:    case 0x3: {
  OPC_CheckPredicate, 23,                    // 3763:     check predicate 23
  OPC_CheckField, 5, 2, 2,                   // 3765:     check Inst[6:5] == 0x2
  OPC_Decode, 249, 14, 114,                  // 3769:     decode to SBFX using decoder 114
                                             // 3769:    }
                                             // 3769:    } // switch Inst[24:23]
                                             // 3769:   }
                                             // 3769:   } // switch Inst[4]
                                             // 3769:  }
  2, 161, 3,                                 // 3773:  case 0x2: {
  OPC_SwitchField, 4, 1,                     // 3776:   switch Inst[4] {
  0, 77,                                     // 3779:   case 0x0: {
  OPC_SwitchField, 20, 1,                    // 3781:    switch Inst[20] {
  0, 19,                                     // 3784:    case 0x0: {
  OPC_SwitchField, 24, 1,                    // 3786:     switch Inst[24] {
  0, 6,                                      // 3789:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 3791:      check predicate 10
  OPC_Decode, 226, 15, 93,                   // 3793:      decode to STRB_POST_REG using decoder 93
                                             // 3793:     }
  1, 0,                                      // 3797:     case 0x1: {
  OPC_CheckPredicate, 10,                    // 3799:      check predicate 10
  OPC_Decode, 230, 15, 115,                  // 3801:      decode to STRBrs using decoder 115
                                             // 3801:     }
                                             // 3801:     } // switch Inst[24]
                                             // 3801:    }
  1, 0,                                      // 3805:    case 0x1: {
  OPC_SwitchField, 24, 1,                    // 3807:     switch Inst[24] {
  0, 22,                                     // 3810:     case 0x0: {
  OPC_Scope, 14,                             // 3812:      try {
  OPC_CheckField, 12, 4, 15,                 // 3814:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 25,                    // 3818:       check predicate 25
  OPC_CheckField, 28, 4, 15,                 // 3820:       check Inst[31:28] == 0xf
  OPC_Decode, 210, 14, 102,                  // 3824:       decode to PLIrs using decoder 102
                                             // 3824:      } else try {
  OPC_CheckPredicate, 10,                    // 3828:       check predicate 10
  OPC_Decode, 181, 7, 93,                    // 3830:       decode to LDRB_POST_REG using decoder 93
                                             // 3830:      }
                                             // 3830:     }
  1, 0,                                      // 3834:     case 0x1: {
  OPC_Scope, 14,                             // 3836:      try {
  OPC_CheckField, 12, 4, 15,                 // 3838:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 10,                    // 3842:       check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 3844:       check Inst[31:28] == 0xf
  OPC_Decode, 208, 14, 102,                  // 3848:       decode to PLDrs using decoder 102
                                             // 3848:      } else try {
  OPC_CheckPredicate, 10,                    // 3852:       check predicate 10
  OPC_Decode, 185, 7, 115,                   // 3854:       decode to LDRBrs using decoder 115
                                             // 3854:      }
                                             // 3854:     }
                                             // 3854:     } // switch Inst[24]
                                             // 3854:    }
                                             // 3854:    } // switch Inst[20]
                                             // 3854:   }
  1, 0,                                      // 3858:   case 0x1: {
  OPC_SwitchField, 5, 2,                     // 3860:    switch Inst[6:5] {
  0, 101,                                    // 3863:    case 0x0: {
  OPC_SwitchField, 23, 2,                    // 3865:     switch Inst[24:23] {
  0, 35,                                     // 3868:     case 0x0: {
  OPC_SwitchField, 7, 1,                     // 3870:      switch Inst[7] {
  0, 14,                                     // 3873:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 3875:       check predicate 10
  OPC_CheckField, 20, 1, 1,                  // 3877:       check Inst[20] == 0x1
  OPC_SoftFail, 0, 128, 30,                  // 3881:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 146, 16, 103,                  // 3885:       decode to UADD16 using decoder 103
                                             // 3885:      }
  1, 0,                                      // 3889:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 3891:       check predicate 10
  OPC_CheckField, 20, 1, 1,                  // 3893:       check Inst[20] == 0x1
  OPC_SoftFail, 0, 128, 30,                  // 3897:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 147, 16, 103,                  // 3901:       decode to UADD8 using decoder 103
                                             // 3901:      }
                                             // 3901:      } // switch Inst[7]
                                             // 3901:     }
  2, 39,                                     // 3905:     case 0x2: {
  OPC_SwitchField, 20, 1,                    // 3907:      switch Inst[20] {
  0, 10,                                     // 3910:      case 0x0: {
  OPC_CheckPredicate, 11,                    // 3912:       check predicate 11
  OPC_CheckField, 7, 1, 0,                   // 3914:       check Inst[7] == 0x0
  OPC_Decode, 150, 15, 57,                   // 3918:       decode to SMLALD using decoder 57
                                             // 3918:      }
  1, 0,                                      // 3922:      case 0x1: {
  OPC_CheckField, 7, 1, 0,                   // 3924:       check Inst[7] == 0x0
  OPC_Scope, 10,                             // 3928:       try {
  OPC_CheckField, 12, 4, 15,                 // 3930:        check Inst[15:12] == 0xf
  OPC_CheckPredicate, 11,                    // 3934:        check predicate 11
  OPC_Decode, 166, 15, 68,                   // 3936:        decode to SMMUL using decoder 68
                                             // 3936:       } else try {
  OPC_CheckPredicate, 11,                    // 3940:        check predicate 11
  OPC_Decode, 162, 15, 77,                   // 3942:        decode to SMMLA using decoder 77
                                             // 3942:       }
                                             // 3942:      }
                                             // 3942:      } // switch Inst[20]
                                             // 3942:     }
  3, 0,                                      // 3946:     case 0x3: {
  OPC_Scope, 10,                             // 3948:      try {
  OPC_CheckField, 0, 4, 15,                  // 3950:       check Inst[3:0] == 0xf
  OPC_CheckPredicate, 23,                    // 3954:       check predicate 23
  OPC_Decode, 185, 6, 116,                   // 3956:       decode to BFC using decoder 116
                                             // 3956:      } else try {
  OPC_CheckPredicate, 23,                    // 3960:       check predicate 23
  OPC_Decode, 186, 6, 117,                   // 3962:       decode to BFI using decoder 117
                                             // 3962:      }
                                             // 3962:     }
                                             // 3962:     } // switch Inst[24:23]
                                             // 3962:    }
  1, 64,                                     // 3966:    case 0x1: {
  OPC_SwitchField, 20, 1,                    // 3968:     switch Inst[20] {
  0, 14,                                     // 3971:     case 0x0: {
  OPC_CheckPredicate, 11,                    // 3973:      check predicate 11
  OPC_CheckField, 23, 2, 2,                  // 3975:      check Inst[24:23] == 0x2
  OPC_CheckField, 7, 1, 0,                   // 3979:      check Inst[7] == 0x0
  OPC_Decode, 151, 15, 57,                   // 3983:      decode to SMLALDX using decoder 57
                                             // 3983:     }
  1, 0,                                      // 3987:     case 0x1: {
  OPC_SwitchField, 23, 2,                    // 3989:      switch Inst[24:23] {
  0, 14,                                     // 3992:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 3994:       check predicate 10
  OPC_CheckField, 7, 1, 0,                   // 3996:       check Inst[7] == 0x0
  OPC_SoftFail, 0, 128, 30,                  // 4000:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 148, 16, 103,                  // 4004:       decode to UASX using decoder 103
                                             // 4004:      }
  2, 0,                                      // 4008:      case 0x2: {
  OPC_CheckField, 7, 1, 0,                   // 4010:       check Inst[7] == 0x0
  OPC_Scope, 10,                             // 4014:       try {
  OPC_CheckField, 12, 4, 15,                 // 4016:        check Inst[15:12] == 0xf
  OPC_CheckPredicate, 11,                    // 4020:        check predicate 11
  OPC_Decode, 167, 15, 68,                   // 4022:        decode to SMMULR using decoder 68
                                             // 4022:       } else try {
  OPC_CheckPredicate, 11,                    // 4026:        check predicate 11
  OPC_Decode, 163, 15, 77,                   // 4028:        decode to SMMLAR using decoder 77
                                             // 4028:       }
                                             // 4028:      }
                                             // 4028:      } // switch Inst[24:23]
                                             // 4028:     }
                                             // 4028:     } // switch Inst[20]
                                             // 4028:    }
  2, 52,                                     // 4032:    case 0x2: {
  OPC_SwitchField, 7, 1,                     // 4034:     switch Inst[7] {
  0, 31,                                     // 4037:     case 0x0: {
  OPC_SwitchField, 20, 1,                    // 4039:      switch Inst[20] {
  0, 10,                                     // 4042:      case 0x0: {
  OPC_CheckPredicate, 11,                    // 4044:       check predicate 11
  OPC_CheckField, 23, 2, 2,                  // 4046:       check Inst[24:23] == 0x2
  OPC_Decode, 160, 15, 57,                   // 4050:       decode to SMLSLD using decoder 57
                                             // 4050:      }
  1, 0,                                      // 4054:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 4056:       check predicate 10
  OPC_CheckField, 23, 2, 0,                  // 4058:       check Inst[24:23] == 0x0
  OPC_SoftFail, 0, 128, 30,                  // 4062:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 171, 16, 103,                  // 4066:       decode to USAX using decoder 103
                                             // 4066:      }
                                             // 4066:      } // switch Inst[20]
                                             // 4066:     }
  1, 0,                                      // 4070:     case 0x1: {
  OPC_CheckPredicate, 11,                    // 4072:      check predicate 11
  OPC_CheckField, 23, 2, 2,                  // 4074:      check Inst[24:23] == 0x2
  OPC_CheckField, 20, 1, 1,                  // 4078:      check Inst[20] == 0x1
  OPC_Decode, 164, 15, 77,                   // 4082:      decode to SMMLS using decoder 77
                                             // 4082:     }
                                             // 4082:     } // switch Inst[7]
                                             // 4082:    }
  3, 0,                                      // 4086:    case 0x3: {
  OPC_SwitchField, 23, 2,                    // 4088:     switch Inst[24:23] {
  0, 35,                                     // 4091:     case 0x0: {
  OPC_SwitchField, 7, 1,                     // 4093:      switch Inst[7] {
  0, 14,                                     // 4096:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 4098:       check predicate 10
  OPC_CheckField, 20, 1, 1,                  // 4100:       check Inst[20] == 0x1
  OPC_SoftFail, 0, 128, 30,                  // 4104:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 172, 16, 103,                  // 4108:       decode to USUB16 using decoder 103
                                             // 4108:      }
  1, 0,                                      // 4112:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 4114:       check predicate 10
  OPC_CheckField, 20, 1, 1,                  // 4116:       check Inst[20] == 0x1
  OPC_SoftFail, 0, 128, 30,                  // 4120:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 173, 16, 103,                  // 4124:       decode to USUB8 using decoder 103
                                             // 4124:      }
                                             // 4124:      } // switch Inst[7]
                                             // 4124:     }
  1, 34,                                     // 4128:     case 0x1: {
  OPC_CheckField, 7, 1, 0,                   // 4130:      check Inst[7] == 0x0
  OPC_CheckField, 20, 1, 0,                  // 4134:      check Inst[20] == 0x0
  OPC_Scope, 14,                             // 4138:      try {
  OPC_CheckField, 16, 4, 15,                 // 4140:       check Inst[19:16] == 0xf
  OPC_CheckPredicate, 11,                    // 4144:       check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 4146:       softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 178, 16, 108,                  // 4150:       decode to UXTB16 using decoder 108
                                             // 4150:      } else try {
  OPC_CheckPredicate, 11,                    // 4154:       check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 4156:       softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 175, 16, 109,                  // 4160:       decode to UXTAB16 using decoder 109
                                             // 4160:      }
                                             // 4160:     }
  2, 0,                                      // 4164:     case 0x2: {
  OPC_SwitchField, 7, 1,                     // 4166:      switch Inst[7] {
  0, 10,                                     // 4169:      case 0x0: {
  OPC_CheckPredicate, 11,                    // 4171:       check predicate 11
  OPC_CheckField, 20, 1, 0,                  // 4173:       check Inst[20] == 0x0
  OPC_Decode, 161, 15, 57,                   // 4177:       decode to SMLSLDX using decoder 57
                                             // 4177:      }
  1, 0,                                      // 4181:      case 0x1: {
  OPC_CheckPredicate, 11,                    // 4183:       check predicate 11
  OPC_CheckField, 20, 1, 1,                  // 4185:       check Inst[20] == 0x1
  OPC_Decode, 165, 15, 77,                   // 4189:       decode to SMMLSR using decoder 77
                                             // 4189:      }
                                             // 4189:      } // switch Inst[7]
                                             // 4189:     }
                                             // 4189:     } // switch Inst[24:23]
                                             // 4189:    }
                                             // 4189:    } // switch Inst[6:5]
                                             // 4189:   }
                                             // 4189:   } // switch Inst[4]
                                             // 4189:  }
  3, 0,                                      // 4193:  case 0x3: {
  OPC_SwitchField, 4, 1,                     // 4195:   switch Inst[4] {
  0, 45,                                     // 4198:   case 0x0: {
  OPC_SwitchField, 20, 1,                    // 4200:    switch Inst[20] {
  0, 19,                                     // 4203:    case 0x0: {
  OPC_SwitchField, 24, 1,                    // 4205:     switch Inst[24] {
  0, 6,                                      // 4208:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 4210:      check predicate 10
  OPC_Decode, 224, 15, 93,                   // 4212:      decode to STRBT_POST_REG using decoder 93
                                             // 4212:     }
  1, 0,                                      // 4216:     case 0x1: {
  OPC_CheckPredicate, 10,                    // 4218:      check predicate 10
  OPC_Decode, 228, 15, 110,                  // 4220:      decode to STRB_PRE_REG using decoder 110
                                             // 4220:     }
                                             // 4220:     } // switch Inst[24]
                                             // 4220:    }
  1, 0,                                      // 4224:    case 0x1: {
  OPC_SwitchField, 24, 1,                    // 4226:     switch Inst[24] {
  0, 6,                                      // 4229:     case 0x0: {
  OPC_CheckPredicate, 10,                    // 4231:      check predicate 10
  OPC_Decode, 179, 7, 93,                    // 4233:      decode to LDRBT_POST_REG using decoder 93
                                             // 4233:     }
  1, 0,                                      // 4237:     case 0x1: {
  OPC_CheckPredicate, 10,                    // 4239:      check predicate 10
  OPC_Decode, 183, 7, 111,                   // 4241:      decode to LDRB_PRE_REG using decoder 111
                                             // 4241:     }
                                             // 4241:     } // switch Inst[24]
                                             // 4241:    }
                                             // 4241:    } // switch Inst[20]
                                             // 4241:   }
  1, 0,                                      // 4245:   case 0x1: {
  OPC_SwitchField, 23, 2,                    // 4247:    switch Inst[24:23] {
  0, 177, 1,                                 // 4250:    case 0x0: {
  OPC_SwitchField, 5, 3,                     // 4253:     switch Inst[7:5] {
  0, 27,                                     // 4256:     case 0x0: {
  OPC_SwitchField, 20, 1,                    // 4258:      switch Inst[20] {
  0, 10,                                     // 4261:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 4263:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4265:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 161, 16, 103,                  // 4269:       decode to UQADD16 using decoder 103
                                             // 4269:      }
  1, 0,                                      // 4273:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 4275:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4277:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 152, 16, 103,                  // 4281:       decode to UHADD16 using decoder 103
                                             // 4281:      }
                                             // 4281:      } // switch Inst[20]
                                             // 4281:     }
  1, 27,                                     // 4285:     case 0x1: {
  OPC_SwitchField, 20, 1,                    // 4287:      switch Inst[20] {
  0, 10,                                     // 4290:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 4292:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4294:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 163, 16, 103,                  // 4298:       decode to UQASX using decoder 103
                                             // 4298:      }
  1, 0,                                      // 4302:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 4304:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4306:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 154, 16, 103,                  // 4310:       decode to UHASX using decoder 103
                                             // 4310:      }
                                             // 4310:      } // switch Inst[20]
                                             // 4310:     }
  2, 27,                                     // 4314:     case 0x2: {
  OPC_SwitchField, 20, 1,                    // 4316:      switch Inst[20] {
  0, 10,                                     // 4319:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 4321:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4323:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 164, 16, 103,                  // 4327:       decode to UQSAX using decoder 103
                                             // 4327:      }
  1, 0,                                      // 4331:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 4333:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4335:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 155, 16, 103,                  // 4339:       decode to UHSAX using decoder 103
                                             // 4339:      }
                                             // 4339:      } // switch Inst[20]
                                             // 4339:     }
  3, 27,                                     // 4343:     case 0x3: {
  OPC_SwitchField, 20, 1,                    // 4345:      switch Inst[20] {
  0, 10,                                     // 4348:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 4350:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4352:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 165, 16, 103,                  // 4356:       decode to UQSUB16 using decoder 103
                                             // 4356:      }
  1, 0,                                      // 4360:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 4362:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4364:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 156, 16, 103,                  // 4368:       decode to UHSUB16 using decoder 103
                                             // 4368:      }
                                             // 4368:      } // switch Inst[20]
                                             // 4368:     }
  4, 27,                                     // 4372:     case 0x4: {
  OPC_SwitchField, 20, 1,                    // 4374:      switch Inst[20] {
  0, 10,                                     // 4377:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 4379:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4381:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 162, 16, 103,                  // 4385:       decode to UQADD8 using decoder 103
                                             // 4385:      }
  1, 0,                                      // 4389:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 4391:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4393:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 153, 16, 103,                  // 4397:       decode to UHADD8 using decoder 103
                                             // 4397:      }
                                             // 4397:      } // switch Inst[20]
                                             // 4397:     }
  7, 0,                                      // 4401:     case 0x7: {
  OPC_SwitchField, 20, 1,                    // 4403:      switch Inst[20] {
  0, 10,                                     // 4406:      case 0x0: {
  OPC_CheckPredicate, 10,                    // 4408:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4410:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 166, 16, 103,                  // 4414:       decode to UQSUB8 using decoder 103
                                             // 4414:      }
  1, 0,                                      // 4418:      case 0x1: {
  OPC_CheckPredicate, 10,                    // 4420:       check predicate 10
  OPC_SoftFail, 0, 128, 30,                  // 4422:       softfail pos=0x00000000 neg=0x00000f00
  OPC_Decode, 157, 16, 103,                  // 4426:       decode to UHSUB8 using decoder 103
                                             // 4426:      }
                                             // 4426:      } // switch Inst[20]
                                             // 4426:     }
                                             // 4426:     } // switch Inst[7:5]
                                             // 4426:    }
  1, 126,                                    // 4430:    case 0x1: {
  OPC_SwitchField, 5, 1,                     // 4432:     switch Inst[5] {
  0, 6,                                      // 4435:     case 0x0: {
  OPC_CheckPredicate, 11,                    // 4437:      check predicate 11
  OPC_Decode, 169, 16, 112,                  // 4439:      decode to USAT using decoder 112
                                             // 4439:     }
  1, 0,                                      // 4443:     case 0x1: {
  OPC_SwitchField, 6, 2,                     // 4445:      switch Inst[7:6] {
  0, 31,                                     // 4448:      case 0x0: {
  OPC_SwitchField, 20, 1,                    // 4450:       switch Inst[20] {
  0, 10,                                     // 4453:       case 0x0: {
  OPC_CheckPredicate, 11,                    // 4455:        check predicate 11
  OPC_CheckField, 8, 4, 15,                  // 4457:        check Inst[11:8] == 0xf
  OPC_Decode, 170, 16, 113,                  // 4461:        decode to USAT16 using decoder 113
                                             // 4461:       }
  1, 0,                                      // 4465:       case 0x1: {
  OPC_CheckPredicate, 23,                    // 4467:        check predicate 23
  OPC_CheckField, 16, 4, 15,                 // 4469:        check Inst[19:16] == 0xf
  OPC_CheckField, 8, 4, 15,                  // 4473:        check Inst[11:8] == 0xf
  OPC_Decode, 221, 14, 73,                   // 4477:        decode to RBIT using decoder 73
                                             // 4477:       }
                                             // 4477:       } // switch Inst[20]
                                             // 4477:      }
  1, 59,                                     // 4481:      case 0x1: {
  OPC_SwitchField, 20, 1,                    // 4483:       switch Inst[20] {
  0, 26,                                     // 4486:       case 0x0: {
  OPC_Scope, 14,                             // 4488:        try {
  OPC_CheckField, 16, 4, 15,                 // 4490:         check Inst[19:16] == 0xf
  OPC_CheckPredicate, 11,                    // 4494:         check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 4496:         softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 177, 16, 108,                  // 4500:         decode to UXTB using decoder 108
                                             // 4500:        } else try {
  OPC_CheckPredicate, 11,                    // 4504:         check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 4506:         softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 174, 16, 109,                  // 4510:         decode to UXTAB using decoder 109
                                             // 4510:        }
                                             // 4510:       }
  1, 0,                                      // 4514:       case 0x1: {
  OPC_Scope, 14,                             // 4516:        try {
  OPC_CheckField, 16, 4, 15,                 // 4518:         check Inst[19:16] == 0xf
  OPC_CheckPredicate, 11,                    // 4522:         check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 4524:         softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 179, 16, 108,                  // 4528:         decode to UXTH using decoder 108
                                             // 4528:        } else try {
  OPC_CheckPredicate, 11,                    // 4532:         check predicate 11
  OPC_SoftFail, 128, 6, 0,                   // 4534:         softfail pos=0x00000300 neg=0x00000000
  OPC_Decode, 176, 16, 109,                  // 4538:         decode to UXTAH using decoder 109
                                             // 4538:        }
                                             // 4538:       }
                                             // 4538:       } // switch Inst[20]
                                             // 4538:      }
  2, 0,                                      // 4542:      case 0x2: {
  OPC_CheckPredicate, 11,                    // 4544:       check predicate 11
  OPC_CheckField, 16, 5, 31,                 // 4546:       check Inst[20:16] == 0x1f
  OPC_CheckField, 8, 4, 15,                  // 4550:       check Inst[11:8] == 0xf
  OPC_Decode, 224, 14, 73,                   // 4554:       decode to REVSH using decoder 73
                                             // 4554:      }
                                             // 4554:      } // switch Inst[7:6]
                                             // 4554:     }
                                             // 4554:     } // switch Inst[5]
                                             // 4554:    }
  3, 0,                                      // 4558:    case 0x3: {
  OPC_SwitchField, 5, 2,                     // 4560:     switch Inst[6:5] {
  2, 6,                                      // 4563:     case 0x2: {
  OPC_CheckPredicate, 23,                    // 4565:      check predicate 23
  OPC_Decode, 149, 16, 114,                  // 4567:      decode to UBFX using decoder 114
                                             // 4567:     }
  3, 0,                                      // 4571:     case 0x3: {
  OPC_CheckField, 7, 1, 1,                   // 4573:      check Inst[7] == 0x1
  OPC_CheckField, 20, 1, 1,                  // 4577:      check Inst[20] == 0x1
  OPC_CheckField, 28, 4, 14,                 // 4581:      check Inst[31:28] == 0xe
  OPC_Scope, 15,                             // 4585:      try {
  OPC_CheckField, 0, 4, 14,                  // 4587:       check Inst[3:0] == 0xe
  OPC_CheckPredicate, 10,                    // 4591:       check predicate 10
  OPC_CheckField, 8, 12, 222, 31,            // 4593:       check Inst[19:8] == 0xfde
  OPC_Decode, 140, 16, 25,                   // 4598:       decode to TRAP using decoder 25
                                             // 4598:      } else try {
  OPC_CheckPredicate, 10,                    // 4602:       check predicate 10
  OPC_Decode, 150, 16, 53,                   // 4604:       decode to UDF using decoder 53
                                             // 4604:      }
                                             // 4604:     }
                                             // 4604:     } // switch Inst[6:5]
                                             // 4604:    }
                                             // 4604:    } // switch Inst[24:23]
                                             // 4604:   }
                                             // 4604:   } // switch Inst[4]
                                             // 4604:  }
                                             // 4604:  } // switch Inst[22:21]
                                             // 4604: }
  4, 155, 4,                                 // 4608: case 0x4: {
  OPC_SwitchField, 20, 5,                    // 4611:  switch Inst[24:20] {
  0, 6,                                      // 4614:  case 0x0: {
  OPC_CheckPredicate, 10,                    // 4616:   check predicate 10
  OPC_Decode, 215, 15, 118,                  // 4618:   decode to STMDA using decoder 118
                                             // 4618:  }
  1, 23,                                     // 4622:  case 0x1: {
  OPC_Scope, 15,                             // 4624:   try {
  OPC_CheckField, 0, 16, 128, 20,            // 4626:    check Inst[15:0] == 0xa00
  OPC_CheckPredicate, 10,                    // 4631:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4633:    check Inst[31:28] == 0xf
  OPC_Decode, 225, 14, 119,                  // 4637:    decode to RFEDA using decoder 119
                                             // 4637:   } else try {
  OPC_CheckPredicate, 10,                    // 4641:    check predicate 10
  OPC_Decode, 170, 7, 118,                   // 4643:    decode to LDMDA using decoder 118
                                             // 4643:   }
                                             // 4643:  }
  2, 6,                                      // 4647:  case 0x2: {
  OPC_CheckPredicate, 10,                    // 4649:   check predicate 10
  OPC_Decode, 216, 15, 120,                  // 4651:   decode to STMDA_UPD using decoder 120
                                             // 4651:  }
  3, 23,                                     // 4655:  case 0x3: {
  OPC_Scope, 15,                             // 4657:   try {
  OPC_CheckField, 0, 16, 128, 20,            // 4659:    check Inst[15:0] == 0xa00
  OPC_CheckPredicate, 10,                    // 4664:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4666:    check Inst[31:28] == 0xf
  OPC_Decode, 226, 14, 119,                  // 4670:    decode to RFEDA_UPD using decoder 119
                                             // 4670:   } else try {
  OPC_CheckPredicate, 10,                    // 4674:    check predicate 10
  OPC_Decode, 171, 7, 120,                   // 4676:    decode to LDMDA_UPD using decoder 120
                                             // 4676:   }
                                             // 4676:  }
  4, 24,                                     // 4680:  case 0x4: {
  OPC_Scope, 16,                             // 4682:   try {
  OPC_CheckField, 5, 15, 168, 208, 1,        // 4684:    check Inst[19:5] == 0x6828
  OPC_CheckPredicate, 10,                    // 4690:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4692:    check Inst[31:28] == 0xf
  OPC_Decode, 179, 15, 121,                  // 4696:    decode to SRSDA using decoder 121
                                             // 4696:   } else try {
  OPC_CheckPredicate, 10,                    // 4700:    check predicate 10
  OPC_Decode, 186, 31, 118,                  // 4702:    decode to sysSTMDA using decoder 118
                                             // 4702:   }
                                             // 4702:  }
  5, 6,                                      // 4706:  case 0x5: {
  OPC_CheckPredicate, 10,                    // 4708:   check predicate 10
  OPC_Decode, 178, 31, 118,                  // 4710:   decode to sysLDMDA using decoder 118
                                             // 4710:  }
  6, 24,                                     // 4714:  case 0x6: {
  OPC_Scope, 16,                             // 4716:   try {
  OPC_CheckField, 5, 15, 168, 208, 1,        // 4718:    check Inst[19:5] == 0x6828
  OPC_CheckPredicate, 10,                    // 4724:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4726:    check Inst[31:28] == 0xf
  OPC_Decode, 180, 15, 121,                  // 4730:    decode to SRSDA_UPD using decoder 121
                                             // 4730:   } else try {
  OPC_CheckPredicate, 10,                    // 4734:    check predicate 10
  OPC_Decode, 187, 31, 120,                  // 4736:    decode to sysSTMDA_UPD using decoder 120
                                             // 4736:   }
                                             // 4736:  }
  7, 6,                                      // 4740:  case 0x7: {
  OPC_CheckPredicate, 10,                    // 4742:   check predicate 10
  OPC_Decode, 179, 31, 120,                  // 4744:   decode to sysLDMDA_UPD using decoder 120
                                             // 4744:  }
  8, 6,                                      // 4748:  case 0x8: {
  OPC_CheckPredicate, 10,                    // 4750:   check predicate 10
  OPC_Decode, 219, 15, 118,                  // 4752:   decode to STMIA using decoder 118
                                             // 4752:  }
  9, 23,                                     // 4756:  case 0x9: {
  OPC_Scope, 15,                             // 4758:   try {
  OPC_CheckField, 0, 16, 128, 20,            // 4760:    check Inst[15:0] == 0xa00
  OPC_CheckPredicate, 10,                    // 4765:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4767:    check Inst[31:28] == 0xf
  OPC_Decode, 229, 14, 119,                  // 4771:    decode to RFEIA using decoder 119
                                             // 4771:   } else try {
  OPC_CheckPredicate, 10,                    // 4775:    check predicate 10
  OPC_Decode, 174, 7, 118,                   // 4777:    decode to LDMIA using decoder 118
                                             // 4777:   }
                                             // 4777:  }
  10, 6,                                     // 4781:  case 0xa: {
  OPC_CheckPredicate, 10,                    // 4783:   check predicate 10
  OPC_Decode, 220, 15, 120,                  // 4785:   decode to STMIA_UPD using decoder 120
                                             // 4785:  }
  11, 23,                                    // 4789:  case 0xb: {
  OPC_Scope, 15,                             // 4791:   try {
  OPC_CheckField, 0, 16, 128, 20,            // 4793:    check Inst[15:0] == 0xa00
  OPC_CheckPredicate, 10,                    // 4798:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4800:    check Inst[31:28] == 0xf
  OPC_Decode, 230, 14, 119,                  // 4804:    decode to RFEIA_UPD using decoder 119
                                             // 4804:   } else try {
  OPC_CheckPredicate, 10,                    // 4808:    check predicate 10
  OPC_Decode, 175, 7, 120,                   // 4810:    decode to LDMIA_UPD using decoder 120
                                             // 4810:   }
                                             // 4810:  }
  12, 24,                                    // 4814:  case 0xc: {
  OPC_Scope, 16,                             // 4816:   try {
  OPC_CheckField, 5, 15, 168, 208, 1,        // 4818:    check Inst[19:5] == 0x6828
  OPC_CheckPredicate, 10,                    // 4824:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4826:    check Inst[31:28] == 0xf
  OPC_Decode, 183, 15, 121,                  // 4830:    decode to SRSIA using decoder 121
                                             // 4830:   } else try {
  OPC_CheckPredicate, 10,                    // 4834:    check predicate 10
  OPC_Decode, 190, 31, 118,                  // 4836:    decode to sysSTMIA using decoder 118
                                             // 4836:   }
                                             // 4836:  }
  13, 6,                                     // 4840:  case 0xd: {
  OPC_CheckPredicate, 10,                    // 4842:   check predicate 10
  OPC_Decode, 182, 31, 118,                  // 4844:   decode to sysLDMIA using decoder 118
                                             // 4844:  }
  14, 24,                                    // 4848:  case 0xe: {
  OPC_Scope, 16,                             // 4850:   try {
  OPC_CheckField, 5, 15, 168, 208, 1,        // 4852:    check Inst[19:5] == 0x6828
  OPC_CheckPredicate, 10,                    // 4858:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4860:    check Inst[31:28] == 0xf
  OPC_Decode, 184, 15, 121,                  // 4864:    decode to SRSIA_UPD using decoder 121
                                             // 4864:   } else try {
  OPC_CheckPredicate, 10,                    // 4868:    check predicate 10
  OPC_Decode, 191, 31, 120,                  // 4870:    decode to sysSTMIA_UPD using decoder 120
                                             // 4870:   }
                                             // 4870:  }
  15, 6,                                     // 4874:  case 0xf: {
  OPC_CheckPredicate, 10,                    // 4876:   check predicate 10
  OPC_Decode, 183, 31, 120,                  // 4878:   decode to sysLDMIA_UPD using decoder 120
                                             // 4878:  }
  16, 6,                                     // 4882:  case 0x10: {
  OPC_CheckPredicate, 10,                    // 4884:   check predicate 10
  OPC_Decode, 217, 15, 118,                  // 4886:   decode to STMDB using decoder 118
                                             // 4886:  }
  17, 23,                                    // 4890:  case 0x11: {
  OPC_Scope, 15,                             // 4892:   try {
  OPC_CheckField, 0, 16, 128, 20,            // 4894:    check Inst[15:0] == 0xa00
  OPC_CheckPredicate, 10,                    // 4899:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4901:    check Inst[31:28] == 0xf
  OPC_Decode, 227, 14, 119,                  // 4905:    decode to RFEDB using decoder 119
                                             // 4905:   } else try {
  OPC_CheckPredicate, 10,                    // 4909:    check predicate 10
  OPC_Decode, 172, 7, 118,                   // 4911:    decode to LDMDB using decoder 118
                                             // 4911:   }
                                             // 4911:  }
  18, 6,                                     // 4915:  case 0x12: {
  OPC_CheckPredicate, 10,                    // 4917:   check predicate 10
  OPC_Decode, 218, 15, 120,                  // 4919:   decode to STMDB_UPD using decoder 120
                                             // 4919:  }
  19, 23,                                    // 4923:  case 0x13: {
  OPC_Scope, 15,                             // 4925:   try {
  OPC_CheckField, 0, 16, 128, 20,            // 4927:    check Inst[15:0] == 0xa00
  OPC_CheckPredicate, 10,                    // 4932:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4934:    check Inst[31:28] == 0xf
  OPC_Decode, 228, 14, 119,                  // 4938:    decode to RFEDB_UPD using decoder 119
                                             // 4938:   } else try {
  OPC_CheckPredicate, 10,                    // 4942:    check predicate 10
  OPC_Decode, 173, 7, 120,                   // 4944:    decode to LDMDB_UPD using decoder 120
                                             // 4944:   }
                                             // 4944:  }
  20, 24,                                    // 4948:  case 0x14: {
  OPC_Scope, 16,                             // 4950:   try {
  OPC_CheckField, 5, 15, 168, 208, 1,        // 4952:    check Inst[19:5] == 0x6828
  OPC_CheckPredicate, 10,                    // 4958:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4960:    check Inst[31:28] == 0xf
  OPC_Decode, 181, 15, 121,                  // 4964:    decode to SRSDB using decoder 121
                                             // 4964:   } else try {
  OPC_CheckPredicate, 10,                    // 4968:    check predicate 10
  OPC_Decode, 188, 31, 118,                  // 4970:    decode to sysSTMDB using decoder 118
                                             // 4970:   }
                                             // 4970:  }
  21, 6,                                     // 4974:  case 0x15: {
  OPC_CheckPredicate, 10,                    // 4976:   check predicate 10
  OPC_Decode, 180, 31, 118,                  // 4978:   decode to sysLDMDB using decoder 118
                                             // 4978:  }
  22, 24,                                    // 4982:  case 0x16: {
  OPC_Scope, 16,                             // 4984:   try {
  OPC_CheckField, 5, 15, 168, 208, 1,        // 4986:    check Inst[19:5] == 0x6828
  OPC_CheckPredicate, 10,                    // 4992:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 4994:    check Inst[31:28] == 0xf
  OPC_Decode, 182, 15, 121,                  // 4998:    decode to SRSDB_UPD using decoder 121
                                             // 4998:   } else try {
  OPC_CheckPredicate, 10,                    // 5002:    check predicate 10
  OPC_Decode, 189, 31, 120,                  // 5004:    decode to sysSTMDB_UPD using decoder 120
                                             // 5004:   }
                                             // 5004:  }
  23, 6,                                     // 5008:  case 0x17: {
  OPC_CheckPredicate, 10,                    // 5010:   check predicate 10
  OPC_Decode, 181, 31, 120,                  // 5012:   decode to sysLDMDB_UPD using decoder 120
                                             // 5012:  }
  24, 6,                                     // 5016:  case 0x18: {
  OPC_CheckPredicate, 10,                    // 5018:   check predicate 10
  OPC_Decode, 221, 15, 118,                  // 5020:   decode to STMIB using decoder 118
                                             // 5020:  }
  25, 23,                                    // 5024:  case 0x19: {
  OPC_Scope, 15,                             // 5026:   try {
  OPC_CheckField, 0, 16, 128, 20,            // 5028:    check Inst[15:0] == 0xa00
  OPC_CheckPredicate, 10,                    // 5033:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 5035:    check Inst[31:28] == 0xf
  OPC_Decode, 231, 14, 119,                  // 5039:    decode to RFEIB using decoder 119
                                             // 5039:   } else try {
  OPC_CheckPredicate, 10,                    // 5043:    check predicate 10
  OPC_Decode, 176, 7, 118,                   // 5045:    decode to LDMIB using decoder 118
                                             // 5045:   }
                                             // 5045:  }
  26, 6,                                     // 5049:  case 0x1a: {
  OPC_CheckPredicate, 10,                    // 5051:   check predicate 10
  OPC_Decode, 222, 15, 120,                  // 5053:   decode to STMIB_UPD using decoder 120
                                             // 5053:  }
  27, 23,                                    // 5057:  case 0x1b: {
  OPC_Scope, 15,                             // 5059:   try {
  OPC_CheckField, 0, 16, 128, 20,            // 5061:    check Inst[15:0] == 0xa00
  OPC_CheckPredicate, 10,                    // 5066:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 5068:    check Inst[31:28] == 0xf
  OPC_Decode, 232, 14, 119,                  // 5072:    decode to RFEIB_UPD using decoder 119
                                             // 5072:   } else try {
  OPC_CheckPredicate, 10,                    // 5076:    check predicate 10
  OPC_Decode, 177, 7, 120,                   // 5078:    decode to LDMIB_UPD using decoder 120
                                             // 5078:   }
                                             // 5078:  }
  28, 24,                                    // 5082:  case 0x1c: {
  OPC_Scope, 16,                             // 5084:   try {
  OPC_CheckField, 5, 15, 168, 208, 1,        // 5086:    check Inst[19:5] == 0x6828
  OPC_CheckPredicate, 10,                    // 5092:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 5094:    check Inst[31:28] == 0xf
  OPC_Decode, 185, 15, 121,                  // 5098:    decode to SRSIB using decoder 121
                                             // 5098:   } else try {
  OPC_CheckPredicate, 10,                    // 5102:    check predicate 10
  OPC_Decode, 192, 31, 118,                  // 5104:    decode to sysSTMIB using decoder 118
                                             // 5104:   }
                                             // 5104:  }
  29, 6,                                     // 5108:  case 0x1d: {
  OPC_CheckPredicate, 10,                    // 5110:   check predicate 10
  OPC_Decode, 184, 31, 118,                  // 5112:   decode to sysLDMIB using decoder 118
                                             // 5112:  }
  30, 24,                                    // 5116:  case 0x1e: {
  OPC_Scope, 16,                             // 5118:   try {
  OPC_CheckField, 5, 15, 168, 208, 1,        // 5120:    check Inst[19:5] == 0x6828
  OPC_CheckPredicate, 10,                    // 5126:    check predicate 10
  OPC_CheckField, 28, 4, 15,                 // 5128:    check Inst[31:28] == 0xf
  OPC_Decode, 186, 15, 121,                  // 5132:    decode to SRSIB_UPD using decoder 121
                                             // 5132:   } else try {
  OPC_CheckPredicate, 10,                    // 5136:    check predicate 10
  OPC_Decode, 193, 31, 120,                  // 5138:    decode to sysSTMIB_UPD using decoder 120
                                             // 5138:   }
                                             // 5138:  }
  31, 0,                                     // 5142:  case 0x1f: {
  OPC_CheckPredicate, 10,                    // 5144:   check predicate 10
  OPC_Decode, 185, 31, 120,                  // 5146:   decode to sysLDMIB_UPD using decoder 120
                                             // 5146:  }
                                             // 5146:  } // switch Inst[24:20]
                                             // 5146: }
  5, 43,                                     // 5150: case 0x5: {
  OPC_Scope, 31,                             // 5152:  try {
  OPC_SwitchField, 24, 1,                    // 5154:   switch Inst[24] {
  0, 6,                                      // 5157:   case 0x0: {
  OPC_CheckPredicate, 10,                    // 5159:    check predicate 10
  OPC_Decode, 201, 6, 122,                   // 5161:    decode to Bcc using decoder 122
                                             // 5161:   }
  1, 0,                                      // 5165:   case 0x1: {
  OPC_Scope, 10,                             // 5167:    try {
  OPC_CheckField, 28, 4, 14,                 // 5169:     check Inst[31:28] == 0xe
  OPC_CheckPredicate, 10,                    // 5173:     check predicate 10
  OPC_Decode, 192, 6, 122,                   // 5175:     decode to BL using decoder 122
                                             // 5175:    } else try {
  OPC_CheckPredicate, 10,                    // 5179:     check predicate 10
  OPC_Decode, 196, 6, 122,                   // 5181:     decode to BL_pred using decoder 122
                                             // 5181:    }
                                             // 5181:   }
                                             // 5181:   } // switch Inst[24]
                                             // 5181:  } else try {
  OPC_CheckPredicate, 21,                    // 5185:   check predicate 21
  OPC_CheckField, 28, 4, 15,                 // 5187:   check Inst[31:28] == 0xf
  OPC_Decode, 195, 6, 123,                   // 5191:   decode to BLXi using decoder 123
                                             // 5191:  }
                                             // 5191: }
  6, 43,                                     // 5195: case 0x6: {
  OPC_SwitchField, 20, 5,                    // 5197:  switch Inst[24:20] {
  4, 18,                                     // 5200:  case 0x4: {
  OPC_Scope, 10,                             // 5202:   try {
  OPC_CheckField, 28, 4, 15,                 // 5204:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 5208:    check predicate 14
  OPC_Decode, 220, 7, 124,                   // 5210:    decode to MCRR2 using decoder 124
                                             // 5210:   } else try {
  OPC_CheckPredicate, 10,                    // 5214:    check predicate 10
  OPC_Decode, 219, 7, 125,                   // 5216:    decode to MCRR using decoder 125
                                             // 5216:   }
                                             // 5216:  }
  5, 0,                                      // 5220:  case 0x5: {
  OPC_Scope, 10,                             // 5222:   try {
  OPC_CheckField, 28, 4, 15,                 // 5224:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 5228:    check predicate 14
  OPC_Decode, 234, 7, 124,                   // 5230:    decode to MRRC2 using decoder 124
                                             // 5230:   } else try {
  OPC_CheckPredicate, 10,                    // 5234:    check predicate 10
  OPC_Decode, 233, 7, 126,                   // 5236:    decode to MRRC using decoder 126
                                             // 5236:   }
                                             // 5236:  }
                                             // 5236:  } // switch Inst[24:20]
                                             // 5236: }
  7, 0,                                      // 5240: case 0x7: {
  OPC_CheckPredicate, 10,                    // 5242:  check predicate 10
  OPC_CheckField, 24, 1, 1,                  // 5244:  check Inst[24] == 0x1
  OPC_Decode, 255, 15, 127,                  // 5248:  decode to SVC using decoder 127
                                             // 5248: }
                                             // 5248: } // switch Inst[27:25]
};
static const uint8_t DecoderTableCoProc32[459] = {
  OPC_SwitchField, 24, 4,                    //   0: switch Inst[27:24] {
  12, 195, 1,                                //   3: case 0xc: {
  OPC_SwitchField, 20, 3,                    //   6:  switch Inst[22:20] {
  0, 24,                                     //   9:  case 0x0: {
  OPC_CheckField, 23, 1, 1,                  //  11:   check Inst[23] == 0x1
  OPC_Scope, 11,                             //  15:   try {
  OPC_CheckField, 28, 4, 15,                 //  17:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    //  21:    check predicate 14
  OPC_Decode, 197, 15, 128, 1,               //  23:    decode to STC2_OPTION using decoder 128
                                             //  23:   } else try {
  OPC_CheckPredicate, 10,                    //  28:    check predicate 10
  OPC_Decode, 205, 15, 128, 1,               //  30:    decode to STC_OPTION using decoder 128
                                             //  30:   }
                                             //  30:  }
  1, 24,                                     //  35:  case 0x1: {
  OPC_CheckField, 23, 1, 1,                  //  37:   check Inst[23] == 0x1
  OPC_Scope, 11,                             //  41:   try {
  OPC_CheckField, 28, 4, 15,                 //  43:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    //  47:    check predicate 14
  OPC_Decode, 159, 7, 128, 1,                //  49:    decode to LDC2_OPTION using decoder 128
                                             //  49:   } else try {
  OPC_CheckPredicate, 10,                    //  54:    check predicate 10
  OPC_Decode, 167, 7, 128, 1,                //  56:    decode to LDC_OPTION using decoder 128
                                             //  56:   }
                                             //  56:  }
  2, 20,                                     //  61:  case 0x2: {
  OPC_Scope, 11,                             //  63:   try {
  OPC_CheckField, 28, 4, 15,                 //  65:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    //  69:    check predicate 14
  OPC_Decode, 198, 15, 128, 1,               //  71:    decode to STC2_POST using decoder 128
                                             //  71:   } else try {
  OPC_CheckPredicate, 10,                    //  76:    check predicate 10
  OPC_Decode, 206, 15, 128, 1,               //  78:    decode to STC_POST using decoder 128
                                             //  78:   }
                                             //  78:  }
  3, 20,                                     //  83:  case 0x3: {
  OPC_Scope, 11,                             //  85:   try {
  OPC_CheckField, 28, 4, 15,                 //  87:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    //  91:    check predicate 14
  OPC_Decode, 160, 7, 128, 1,                //  93:    decode to LDC2_POST using decoder 128
                                             //  93:   } else try {
  OPC_CheckPredicate, 10,                    //  98:    check predicate 10
  OPC_Decode, 168, 7, 128, 1,                // 100:    decode to LDC_POST using decoder 128
                                             // 100:   }
                                             // 100:  }
  4, 24,                                     // 105:  case 0x4: {
  OPC_CheckField, 23, 1, 1,                  // 107:   check Inst[23] == 0x1
  OPC_Scope, 11,                             // 111:   try {
  OPC_CheckField, 28, 4, 15,                 // 113:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 117:    check predicate 14
  OPC_Decode, 193, 15, 128, 1,               // 119:    decode to STC2L_OPTION using decoder 128
                                             // 119:   } else try {
  OPC_CheckPredicate, 10,                    // 124:    check predicate 10
  OPC_Decode, 201, 15, 128, 1,               // 126:    decode to STCL_OPTION using decoder 128
                                             // 126:   }
                                             // 126:  }
  5, 24,                                     // 131:  case 0x5: {
  OPC_CheckField, 23, 1, 1,                  // 133:   check Inst[23] == 0x1
  OPC_Scope, 11,                             // 137:   try {
  OPC_CheckField, 28, 4, 15,                 // 139:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 143:    check predicate 14
  OPC_Decode, 155, 7, 128, 1,                // 145:    decode to LDC2L_OPTION using decoder 128
                                             // 145:   } else try {
  OPC_CheckPredicate, 10,                    // 150:    check predicate 10
  OPC_Decode, 163, 7, 128, 1,                // 152:    decode to LDCL_OPTION using decoder 128
                                             // 152:   }
                                             // 152:  }
  6, 20,                                     // 157:  case 0x6: {
  OPC_Scope, 11,                             // 159:   try {
  OPC_CheckField, 28, 4, 15,                 // 161:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 165:    check predicate 14
  OPC_Decode, 194, 15, 128, 1,               // 167:    decode to STC2L_POST using decoder 128
                                             // 167:   } else try {
  OPC_CheckPredicate, 10,                    // 172:    check predicate 10
  OPC_Decode, 202, 15, 128, 1,               // 174:    decode to STCL_POST using decoder 128
                                             // 174:   }
                                             // 174:  }
  7, 0,                                      // 179:  case 0x7: {
  OPC_Scope, 11,                             // 181:   try {
  OPC_CheckField, 28, 4, 15,                 // 183:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 187:    check predicate 14
  OPC_Decode, 156, 7, 128, 1,                // 189:    decode to LDC2L_POST using decoder 128
                                             // 189:   } else try {
  OPC_CheckPredicate, 10,                    // 194:    check predicate 10
  OPC_Decode, 164, 7, 128, 1,                // 196:    decode to LDCL_POST using decoder 128
                                             // 196:   }
                                             // 196:  }
                                             // 196:  } // switch Inst[22:20]
                                             // 196: }
  13, 179, 1,                                // 201: case 0xd: {
  OPC_SwitchField, 20, 3,                    // 204:  switch Inst[22:20] {
  0, 20,                                     // 207:  case 0x0: {
  OPC_Scope, 11,                             // 209:   try {
  OPC_CheckField, 28, 4, 15,                 // 211:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 215:    check predicate 14
  OPC_Decode, 196, 15, 128, 1,               // 217:    decode to STC2_OFFSET using decoder 128
                                             // 217:   } else try {
  OPC_CheckPredicate, 10,                    // 222:    check predicate 10
  OPC_Decode, 204, 15, 128, 1,               // 224:    decode to STC_OFFSET using decoder 128
                                             // 224:   }
                                             // 224:  }
  1, 20,                                     // 229:  case 0x1: {
  OPC_Scope, 11,                             // 231:   try {
  OPC_CheckField, 28, 4, 15,                 // 233:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 237:    check predicate 14
  OPC_Decode, 158, 7, 128, 1,                // 239:    decode to LDC2_OFFSET using decoder 128
                                             // 239:   } else try {
  OPC_CheckPredicate, 10,                    // 244:    check predicate 10
  OPC_Decode, 166, 7, 128, 1,                // 246:    decode to LDC_OFFSET using decoder 128
                                             // 246:   }
                                             // 246:  }
  2, 20,                                     // 251:  case 0x2: {
  OPC_Scope, 11,                             // 253:   try {
  OPC_CheckField, 28, 4, 15,                 // 255:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 259:    check predicate 14
  OPC_Decode, 199, 15, 128, 1,               // 261:    decode to STC2_PRE using decoder 128
                                             // 261:   } else try {
  OPC_CheckPredicate, 10,                    // 266:    check predicate 10
  OPC_Decode, 207, 15, 128, 1,               // 268:    decode to STC_PRE using decoder 128
                                             // 268:   }
                                             // 268:  }
  3, 20,                                     // 273:  case 0x3: {
  OPC_Scope, 11,                             // 275:   try {
  OPC_CheckField, 28, 4, 15,                 // 277:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 281:    check predicate 14
  OPC_Decode, 161, 7, 128, 1,                // 283:    decode to LDC2_PRE using decoder 128
                                             // 283:   } else try {
  OPC_CheckPredicate, 10,                    // 288:    check predicate 10
  OPC_Decode, 169, 7, 128, 1,                // 290:    decode to LDC_PRE using decoder 128
                                             // 290:   }
                                             // 290:  }
  4, 20,                                     // 295:  case 0x4: {
  OPC_Scope, 11,                             // 297:   try {
  OPC_CheckField, 28, 4, 15,                 // 299:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 303:    check predicate 14
  OPC_Decode, 192, 15, 128, 1,               // 305:    decode to STC2L_OFFSET using decoder 128
                                             // 305:   } else try {
  OPC_CheckPredicate, 10,                    // 310:    check predicate 10
  OPC_Decode, 200, 15, 128, 1,               // 312:    decode to STCL_OFFSET using decoder 128
                                             // 312:   }
                                             // 312:  }
  5, 20,                                     // 317:  case 0x5: {
  OPC_Scope, 11,                             // 319:   try {
  OPC_CheckField, 28, 4, 15,                 // 321:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 325:    check predicate 14
  OPC_Decode, 154, 7, 128, 1,                // 327:    decode to LDC2L_OFFSET using decoder 128
                                             // 327:   } else try {
  OPC_CheckPredicate, 10,                    // 332:    check predicate 10
  OPC_Decode, 162, 7, 128, 1,                // 334:    decode to LDCL_OFFSET using decoder 128
                                             // 334:   }
                                             // 334:  }
  6, 20,                                     // 339:  case 0x6: {
  OPC_Scope, 11,                             // 341:   try {
  OPC_CheckField, 28, 4, 15,                 // 343:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 347:    check predicate 14
  OPC_Decode, 195, 15, 128, 1,               // 349:    decode to STC2L_PRE using decoder 128
                                             // 349:   } else try {
  OPC_CheckPredicate, 10,                    // 354:    check predicate 10
  OPC_Decode, 203, 15, 128, 1,               // 356:    decode to STCL_PRE using decoder 128
                                             // 356:   }
                                             // 356:  }
  7, 0,                                      // 361:  case 0x7: {
  OPC_Scope, 11,                             // 363:   try {
  OPC_CheckField, 28, 4, 15,                 // 365:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 369:    check predicate 14
  OPC_Decode, 157, 7, 128, 1,                // 371:    decode to LDC2L_PRE using decoder 128
                                             // 371:   } else try {
  OPC_CheckPredicate, 10,                    // 376:    check predicate 10
  OPC_Decode, 165, 7, 128, 1,                // 378:    decode to LDCL_PRE using decoder 128
                                             // 378:   }
                                             // 378:  }
                                             // 378:  } // switch Inst[22:20]
                                             // 378: }
  14, 0,                                     // 383: case 0xe: {
  OPC_SwitchField, 4, 1,                     // 385:  switch Inst[4] {
  0, 20,                                     // 388:  case 0x0: {
  OPC_Scope, 11,                             // 390:   try {
  OPC_CheckField, 28, 4, 15,                 // 392:    check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 396:    check predicate 14
  OPC_Decode, 233, 6, 129, 1,                // 398:    decode to CDP2 using decoder 129
                                             // 398:   } else try {
  OPC_CheckPredicate, 14,                    // 403:    check predicate 14
  OPC_Decode, 232, 6, 130, 1,                // 405:    decode to CDP using decoder 130
                                             // 405:   }
                                             // 405:  }
  1, 0,                                      // 410:  case 0x1: {
  OPC_SwitchField, 20, 1,                    // 412:   switch Inst[20] {
  0, 20,                                     // 415:   case 0x0: {
  OPC_Scope, 11,                             // 417:    try {
  OPC_CheckField, 28, 4, 15,                 // 419:     check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 423:     check predicate 14
  OPC_Decode, 218, 7, 131, 1,                // 425:     decode to MCR2 using decoder 131
                                             // 425:    } else try {
  OPC_CheckPredicate, 10,                    // 430:     check predicate 10
  OPC_Decode, 217, 7, 132, 1,                // 432:     decode to MCR using decoder 132
                                             // 432:    }
                                             // 432:   }
  1, 0,                                      // 437:   case 0x1: {
  OPC_Scope, 11,                             // 439:    try {
  OPC_CheckField, 28, 4, 15,                 // 441:     check Inst[31:28] == 0xf
  OPC_CheckPredicate, 14,                    // 445:     check predicate 14
  OPC_Decode, 232, 7, 133, 1,                // 447:     decode to MRC2 using decoder 133
                                             // 447:    } else try {
  OPC_CheckPredicate, 10,                    // 452:     check predicate 10
  OPC_Decode, 231, 7, 134, 1,                // 454:     decode to MRC using decoder 134
                                             // 454:    }
                                             // 454:   }
                                             // 454:   } // switch Inst[20]
                                             // 454:  }
                                             // 454:  } // switch Inst[4]
                                             // 454: }
                                             // 454: } // switch Inst[27:24]
};
static const uint8_t DecoderTableMVE32[15451] = {
  OPC_SwitchField, 25, 3,                    //     0: switch Inst[27:25] {
  0, 87,                                     //     3: case 0x0: {
  OPC_SwitchField, 20, 5,                    //     5:  switch Inst[24:20] {
  0, 19,                                     //     8:  case 0x0: {
  OPC_CheckPredicate, 31,                    //    10:   check predicate 31
  OPC_CheckField, 28, 4, 15,                 //    12:   check Inst[31:28] == 0xf
  OPC_CheckField, 11, 5, 29,                 //    16:   check Inst[15:11] == 0x1d
  OPC_SoftFail, 254, 15, 1,                  //    20:   softfail pos=0x000007fe neg=0x00000001
  OPC_Decode, 231, 8, 135, 1,                //    24:   decode to MVE_VCTP8 using decoder 135
                                             //    24:  }
  1, 19,                                     //    29:  case 0x1: {
  OPC_CheckPredicate, 31,                    //    31:   check predicate 31
  OPC_CheckField, 28, 4, 15,                 //    33:   check Inst[31:28] == 0xf
  OPC_CheckField, 11, 5, 29,                 //    37:   check Inst[15:11] == 0x1d
  OPC_SoftFail, 254, 15, 1,                  //    41:   softfail pos=0x000007fe neg=0x00000001
  OPC_Decode, 228, 8, 135, 1,                //    45:   decode to MVE_VCTP16 using decoder 135
                                             //    45:  }
  2, 19,                                     //    50:  case 0x2: {
  OPC_CheckPredicate, 31,                    //    52:   check predicate 31
  OPC_CheckField, 28, 4, 15,                 //    54:   check Inst[31:28] == 0xf
  OPC_CheckField, 11, 5, 29,                 //    58:   check Inst[15:11] == 0x1d
  OPC_SoftFail, 254, 15, 1,                  //    62:   softfail pos=0x000007fe neg=0x00000001
  OPC_Decode, 229, 8, 135, 1,                //    66:   decode to MVE_VCTP32 using decoder 135
                                             //    66:  }
  3, 0,                                      //    71:  case 0x3: {
  OPC_CheckPredicate, 31,                    //    73:   check predicate 31
  OPC_CheckField, 28, 4, 15,                 //    75:   check Inst[31:28] == 0xf
  OPC_CheckField, 11, 5, 29,                 //    79:   check Inst[15:11] == 0x1d
  OPC_SoftFail, 254, 15, 1,                  //    83:   softfail pos=0x000007fe neg=0x00000001
  OPC_Decode, 230, 8, 135, 1,                //    87:   decode to MVE_VCTP64 using decoder 135
                                             //    87:  }
                                             //    87:  } // switch Inst[24:20]
                                             //    87: }
  5, 192, 2,                                 //    92: case 0x5: {
  OPC_SwitchField, 0, 6,                     //    95:  switch Inst[5:0] {
  13, 59,                                    //    98:  case 0xd: {
  OPC_CheckField, 20, 5, 5,                  //   100:   check Inst[24:20] == 0x5
  OPC_CheckField, 28, 4, 14,                 //   104:   check Inst[31:28] == 0xe
  OPC_Scope, 33,                             //   108:   try {
  OPC_SwitchField, 16, 1,                    //   110:    switch Inst[16] {
  0, 11,                                     //   113:    case 0x0: {
  OPC_CheckPredicate, 32,                    //   115:     check predicate 32
  OPC_CheckField, 6, 3, 4,                   //   117:     check Inst[8:6] == 0x4
  OPC_Decode, 251, 7, 136, 1,                //   121:     decode to MVE_LSLLr using decoder 136
                                             //   121:    }
  1, 0,                                      //   126:    case 0x1: {
  OPC_CheckPredicate, 32,                    //   128:     check predicate 32
  OPC_CheckField, 8, 1, 1,                   //   130:     check Inst[8] == 0x1
  OPC_CheckField, 6, 1, 0,                   //   134:     check Inst[6] == 0x0
  OPC_Decode, 132, 8, 136, 1,                //   138:     decode to MVE_UQRSHLL using decoder 136
                                             //   138:    }
                                             //   138:    } // switch Inst[16]
                                             //   138:   } else try {
  OPC_CheckPredicate, 32,                    //   143:    check predicate 32
  OPC_CheckField, 9, 3, 7,                   //   145:    check Inst[11:9] == 0x7
  OPC_SoftFail, 192, 1, 128, 2,              //   149:    softfail pos=0x000000c0 neg=0x00000100
  OPC_Decode, 131, 8, 137, 1,                //   154:    decode to MVE_UQRSHL using decoder 137
                                             //   154:   }
                                             //   154:  }
  15, 49,                                    //   159:  case 0xf: {
  OPC_CheckField, 8, 1, 1,                   //   161:   check Inst[8] == 0x1
  OPC_CheckField, 15, 1, 0,                  //   165:   check Inst[15] == 0x0
  OPC_CheckField, 20, 5, 5,                  //   169:   check Inst[24:20] == 0x5
  OPC_CheckField, 28, 4, 14,                 //   173:   check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //   177:   try {
  OPC_CheckField, 9, 3, 7,                   //   179:    check Inst[11:9] == 0x7
  OPC_CheckPredicate, 32,                    //   183:    check predicate 32
  OPC_Decode, 133, 8, 138, 1,                //   185:    decode to MVE_UQSHL using decoder 138
  OPC_Scope, 11,                             //   190:   } else try {
  OPC_CheckField, 16, 1, 1,                  //   192:    check Inst[16] == 0x1
  OPC_CheckPredicate, 32,                    //   196:    check predicate 32
  OPC_Decode, 134, 8, 139, 1,                //   198:    decode to MVE_UQSHLL using decoder 139
                                             //   198:   } else try {
  OPC_CheckPredicate, 32,                    //   203:    check predicate 32
  OPC_Decode, 250, 7, 139, 1,                //   205:    decode to MVE_LSLLi using decoder 139
                                             //   205:   }
                                             //   205:  }
  31, 49,                                    //   210:  case 0x1f: {
  OPC_CheckField, 8, 1, 1,                   //   212:   check Inst[8] == 0x1
  OPC_CheckField, 15, 1, 0,                  //   216:   check Inst[15] == 0x0
  OPC_CheckField, 20, 5, 5,                  //   220:   check Inst[24:20] == 0x5
  OPC_CheckField, 28, 4, 14,                 //   224:   check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //   228:   try {
  OPC_CheckField, 9, 3, 7,                   //   230:    check Inst[11:9] == 0x7
  OPC_CheckPredicate, 32,                    //   234:    check predicate 32
  OPC_Decode, 135, 8, 138, 1,                //   236:    decode to MVE_URSHR using decoder 138
  OPC_Scope, 11,                             //   241:   } else try {
  OPC_CheckField, 16, 1, 1,                  //   243:    check Inst[16] == 0x1
  OPC_CheckPredicate, 32,                    //   247:    check predicate 32
  OPC_Decode, 136, 8, 139, 1,                //   249:    decode to MVE_URSHRL using decoder 139
                                             //   249:   } else try {
  OPC_CheckPredicate, 32,                    //   254:    check predicate 32
  OPC_Decode, 252, 7, 139, 1,                //   256:    decode to MVE_LSRL using decoder 139
                                             //   256:   }
                                             //   256:  }
  45, 59,                                    //   261:  case 0x2d: {
  OPC_CheckField, 20, 5, 5,                  //   263:   check Inst[24:20] == 0x5
  OPC_CheckField, 28, 4, 14,                 //   267:   check Inst[31:28] == 0xe
  OPC_Scope, 33,                             //   271:   try {
  OPC_SwitchField, 16, 1,                    //   273:    switch Inst[16] {
  0, 11,                                     //   276:    case 0x0: {
  OPC_CheckPredicate, 32,                    //   278:     check predicate 32
  OPC_CheckField, 6, 3, 4,                   //   280:     check Inst[8:6] == 0x4
  OPC_Decode, 243, 7, 136, 1,                //   284:     decode to MVE_ASRLr using decoder 136
                                             //   284:    }
  1, 0,                                      //   289:    case 0x1: {
  OPC_CheckPredicate, 32,                    //   291:     check predicate 32
  OPC_CheckField, 8, 1, 1,                   //   293:     check Inst[8] == 0x1
  OPC_CheckField, 6, 1, 0,                   //   297:     check Inst[6] == 0x0
  OPC_Decode, 254, 7, 136, 1,                //   301:     decode to MVE_SQRSHRL using decoder 136
                                             //   301:    }
                                             //   301:    } // switch Inst[16]
                                             //   301:   } else try {
  OPC_CheckPredicate, 32,                    //   306:    check predicate 32
  OPC_CheckField, 9, 3, 7,                   //   308:    check Inst[11:9] == 0x7
  OPC_SoftFail, 192, 1, 128, 2,              //   312:    softfail pos=0x000000c0 neg=0x00000100
  OPC_Decode, 253, 7, 137, 1,                //   317:    decode to MVE_SQRSHR using decoder 137
                                             //   317:   }
                                             //   317:  }
  47, 49,                                    //   322:  case 0x2f: {
  OPC_CheckField, 8, 1, 1,                   //   324:   check Inst[8] == 0x1
  OPC_CheckField, 15, 1, 0,                  //   328:   check Inst[15] == 0x0
  OPC_CheckField, 20, 5, 5,                  //   332:   check Inst[24:20] == 0x5
  OPC_CheckField, 28, 4, 14,                 //   336:   check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //   340:   try {
  OPC_CheckField, 9, 3, 7,                   //   342:    check Inst[11:9] == 0x7
  OPC_CheckPredicate, 32,                    //   346:    check predicate 32
  OPC_Decode, 129, 8, 138, 1,                //   348:    decode to MVE_SRSHR using decoder 138
  OPC_Scope, 11,                             //   353:   } else try {
  OPC_CheckField, 16, 1, 1,                  //   355:    check Inst[16] == 0x1
  OPC_CheckPredicate, 32,                    //   359:    check predicate 32
  OPC_Decode, 130, 8, 139, 1,                //   361:    decode to MVE_SRSHRL using decoder 139
                                             //   361:   } else try {
  OPC_CheckPredicate, 32,                    //   366:    check predicate 32
  OPC_Decode, 242, 7, 139, 1,                //   368:    decode to MVE_ASRLi using decoder 139
                                             //   368:   }
                                             //   368:  }
  63, 0,                                     //   373:  case 0x3f: {
  OPC_CheckField, 8, 1, 1,                   //   375:   check Inst[8] == 0x1
  OPC_CheckField, 15, 1, 0,                  //   379:   check Inst[15] == 0x0
  OPC_CheckField, 20, 5, 5,                  //   383:   check Inst[24:20] == 0x5
  OPC_CheckField, 28, 4, 14,                 //   387:   check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //   391:   try {
  OPC_CheckField, 9, 3, 7,                   //   393:    check Inst[11:9] == 0x7
  OPC_CheckPredicate, 32,                    //   397:    check predicate 32
  OPC_Decode, 255, 7, 138, 1,                //   399:    decode to MVE_SQSHL using decoder 138
                                             //   399:   } else try {
  OPC_CheckPredicate, 32,                    //   404:    check predicate 32
  OPC_CheckField, 16, 1, 1,                  //   406:    check Inst[16] == 0x1
  OPC_Decode, 128, 8, 139, 1,                //   410:    decode to MVE_SQSHLL using decoder 139
                                             //   410:   }
                                             //   410:  }
                                             //   410:  } // switch Inst[5:0]
                                             //   410: }
  6, 164, 23,                                //   415: case 0x6: {
  OPC_SwitchField, 8, 5,                     //   418:  switch Inst[12:8] {
  8, 127,                                    //   421:  case 0x8: {
  OPC_SwitchField, 20, 2,                    //   423:   switch Inst[21:20] {
  0, 31,                                     //   426:   case 0x0: {
  OPC_CheckPredicate, 33,                    //   428:    check predicate 33
  OPC_CheckField, 28, 4, 15,                 //   430:    check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //   434:    check Inst[23] == 0x1
  OPC_CheckField, 16, 1, 0,                  //   438:    check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   //   442:    check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   //   446:    check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //   450:    check Inst[0] == 0x0
  OPC_Decode, 191, 8, 140, 1,                //   454:    decode to MVE_VCADDf16 using decoder 140
                                             //   454:   }
  1, 31,                                     //   459:   case 0x1: {
  OPC_CheckPredicate, 33,                    //   461:    check predicate 33
  OPC_CheckField, 28, 4, 15,                 //   463:    check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //   467:    check Inst[23] == 0x1
  OPC_CheckField, 16, 1, 0,                  //   471:    check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   //   475:    check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   //   479:    check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //   483:    check Inst[0] == 0x0
  OPC_Decode, 192, 8, 140, 1,                //   487:    decode to MVE_VCADDf32 using decoder 140
                                             //   487:   }
  2, 27,                                     //   492:   case 0x2: {
  OPC_CheckPredicate, 33,                    //   494:    check predicate 33
  OPC_CheckField, 28, 4, 15,                 //   496:    check Inst[31:28] == 0xf
  OPC_CheckField, 16, 1, 0,                  //   500:    check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   //   504:    check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   //   508:    check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //   512:    check Inst[0] == 0x0
  OPC_Decode, 202, 8, 141, 1,                //   516:    decode to MVE_VCMLAf16 using decoder 141
                                             //   516:   }
  3, 0,                                      //   521:   case 0x3: {
  OPC_CheckPredicate, 33,                    //   523:    check predicate 33
  OPC_CheckField, 28, 4, 15,                 //   525:    check Inst[31:28] == 0xf
  OPC_CheckField, 16, 1, 0,                  //   529:    check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   //   533:    check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   //   537:    check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //   541:    check Inst[0] == 0x0
  OPC_Decode, 203, 8, 141, 1,                //   545:    decode to MVE_VCMLAf32 using decoder 141
                                             //   545:   }
                                             //   545:   } // switch Inst[21:20]
                                             //   545:  }
  14, 140, 3,                                //   550:  case 0xe: {
  OPC_SwitchField, 20, 3,                    //   553:   switch Inst[22:20] {
  0, 115,                                    //   556:   case 0x0: {
  OPC_SwitchField, 7, 1,                     //   558:    switch Inst[7] {
  0, 23,                                     //   561:    case 0x0: {
  OPC_CheckPredicate, 31,                    //   563:     check predicate 31
  OPC_CheckField, 28, 4, 14,                 //   565:     check Inst[31:28] == 0xe
  OPC_CheckField, 23, 2, 1,                  //   569:     check Inst[24:23] == 0x1
  OPC_CheckField, 4, 3, 0,                   //   573:     check Inst[6:4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //   577:     check Inst[0] == 0x0
  OPC_Decode, 148, 14, 142, 1,               //   581:     decode to MVE_VSTRB8_rq using decoder 142
                                             //   581:    }
  1, 0,                                      //   586:    case 0x1: {
  OPC_SwitchField, 24, 1,                    //   588:     switch Inst[24] {
  0, 63,                                     //   591:     case 0x0: {
  OPC_SwitchField, 0, 1,                     //   593:      switch Inst[0] {
  0, 37,                                     //   596:      case 0x0: {
  OPC_SwitchField, 4, 3,                     //   598:       switch Inst[6:4] {
  0, 15,                                     //   601:       case 0x0: {
  OPC_CheckPredicate, 31,                    //   603:        check predicate 31
  OPC_CheckField, 28, 4, 14,                 //   605:        check Inst[31:28] == 0xe
  OPC_CheckField, 23, 1, 1,                  //   609:        check Inst[23] == 0x1
  OPC_Decode, 143, 14, 142, 1,               //   613:        decode to MVE_VSTRB16_rq using decoder 142
                                             //   613:       }
  1, 0,                                      //   618:       case 0x1: {
  OPC_CheckPredicate, 31,                    //   620:        check predicate 31
  OPC_CheckField, 28, 4, 14,                 //   622:        check Inst[31:28] == 0xe
  OPC_CheckField, 23, 1, 1,                  //   626:        check Inst[23] == 0x1
  OPC_Decode, 157, 14, 142, 1,               //   630:        decode to MVE_VSTRH16_rq_u using decoder 142
                                             //   630:       }
                                             //   630:       } // switch Inst[6:4]
                                             //   630:      }
  1, 0,                                      //   635:      case 0x1: {
  OPC_CheckPredicate, 31,                    //   637:       check predicate 31
  OPC_CheckField, 28, 4, 14,                 //   639:       check Inst[31:28] == 0xe
  OPC_CheckField, 23, 1, 1,                  //   643:       check Inst[23] == 0x1
  OPC_CheckField, 4, 3, 1,                   //   647:       check Inst[6:4] == 0x1
  OPC_Decode, 156, 14, 142, 1,               //   651:       decode to MVE_VSTRH16_rq using decoder 142
                                             //   651:      }
                                             //   651:      } // switch Inst[0]
                                             //   651:     }
  1, 0,                                      //   656:     case 0x1: {
  OPC_CheckPredicate, 31,                    //   658:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //   660:      check Inst[31:28] == 0xe
  OPC_CheckField, 19, 1, 0,                  //   664:      check Inst[19] == 0x0
  OPC_Decode, 140, 14, 143, 1,               //   668:      decode to MVE_VSTRB16 using decoder 143
                                             //   668:     }
                                             //   668:     } // switch Inst[24]
                                             //   668:    }
                                             //   668:    } // switch Inst[7]
                                             //   668:   }
  1, 143, 1,                                 //   673:   case 0x1: {
  OPC_SwitchField, 7, 1,                     //   676:    switch Inst[7] {
  0, 23,                                     //   679:    case 0x0: {
  OPC_CheckPredicate, 31,                    //   681:     check predicate 31
  OPC_CheckField, 28, 4, 15,                 //   683:     check Inst[31:28] == 0xf
  OPC_CheckField, 23, 2, 1,                  //   687:     check Inst[24:23] == 0x1
  OPC_CheckField, 4, 3, 0,                   //   691:     check Inst[6:4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //   695:     check Inst[0] == 0x0
  OPC_Decode, 246, 9, 142, 1,                //   699:     decode to MVE_VLDRBU8_rq using decoder 142
                                             //   699:    }
  1, 0,                                      //   704:    case 0x1: {
  OPC_SwitchField, 24, 1,                    //   706:     switch Inst[24] {
  0, 77,                                     //   709:     case 0x0: {
  OPC_SwitchField, 0, 1,                     //   711:      switch Inst[0] {
  0, 51,                                     //   714:      case 0x0: {
  OPC_SwitchField, 4, 3,                     //   716:       switch Inst[6:4] {
  0, 29,                                     //   719:       case 0x0: {
  OPC_SwitchField, 28, 4,                    //   721:        switch Inst[31:28] {
  14, 11,                                    //   724:        case 0xe: {
  OPC_CheckPredicate, 31,                    //   726:         check predicate 31
  OPC_CheckField, 23, 1, 1,                  //   728:         check Inst[23] == 0x1
  OPC_Decode, 230, 9, 142, 1,                //   732:         decode to MVE_VLDRBS16_rq using decoder 142
                                             //   732:        }
  15, 0,                                     //   737:        case 0xf: {
  OPC_CheckPredicate, 31,                    //   739:         check predicate 31
  OPC_CheckField, 23, 1, 1,                  //   741:         check Inst[23] == 0x1
  OPC_Decode, 238, 9, 142, 1,                //   745:         decode to MVE_VLDRBU16_rq using decoder 142
                                             //   745:        }
                                             //   745:        } // switch Inst[31:28]
                                             //   745:       }
  1, 0,                                      //   750:       case 0x1: {
  OPC_CheckPredicate, 31,                    //   752:        check predicate 31
  OPC_CheckField, 28, 4, 15,                 //   754:        check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //   758:        check Inst[23] == 0x1
  OPC_Decode, 132, 10, 142, 1,               //   762:        decode to MVE_VLDRHU16_rq_u using decoder 142
                                             //   762:       }
                                             //   762:       } // switch Inst[6:4]
                                             //   762:      }
  1, 0,                                      //   767:      case 0x1: {
  OPC_CheckPredicate, 31,                    //   769:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //   771:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //   775:       check Inst[23] == 0x1
  OPC_CheckField, 4, 3, 1,                   //   779:       check Inst[6:4] == 0x1
  OPC_Decode, 131, 10, 142, 1,               //   783:       decode to MVE_VLDRHU16_rq using decoder 142
                                             //   783:      }
                                             //   783:      } // switch Inst[0]
                                             //   783:     }
  1, 0,                                      //   788:     case 0x1: {
  OPC_SwitchField, 28, 4,                    //   790:      switch Inst[31:28] {
  14, 11,                                    //   793:      case 0xe: {
  OPC_CheckPredicate, 31,                    //   795:       check predicate 31
  OPC_CheckField, 19, 1, 0,                  //   797:       check Inst[19] == 0x0
  OPC_Decode, 227, 9, 143, 1,                //   801:       decode to MVE_VLDRBS16 using decoder 143
                                             //   801:      }
  15, 0,                                     //   806:      case 0xf: {
  OPC_CheckPredicate, 31,                    //   808:       check predicate 31
  OPC_CheckField, 19, 1, 0,                  //   810:       check Inst[19] == 0x0
  OPC_Decode, 235, 9, 143, 1,                //   814:       decode to MVE_VLDRBU16 using decoder 143
                                             //   814:      }
                                             //   814:      } // switch Inst[31:28]
                                             //   814:     }
                                             //   814:     } // switch Inst[24]
                                             //   814:    }
                                             //   814:    } // switch Inst[7]
                                             //   814:   }
  2, 45,                                     //   819:   case 0x2: {
  OPC_SwitchField, 24, 1,                    //   821:    switch Inst[24] {
  0, 19,                                     //   824:    case 0x0: {
  OPC_CheckPredicate, 31,                    //   826:     check predicate 31
  OPC_CheckField, 28, 4, 14,                 //   828:     check Inst[31:28] == 0xe
  OPC_CheckField, 19, 1, 0,                  //   832:     check Inst[19] == 0x0
  OPC_CheckField, 7, 1, 1,                   //   836:     check Inst[7] == 0x1
  OPC_Decode, 141, 14, 144, 1,               //   840:     decode to MVE_VSTRB16_post using decoder 144
                                             //   840:    }
  1, 0,                                      //   845:    case 0x1: {
  OPC_CheckPredicate, 31,                    //   847:     check predicate 31
  OPC_CheckField, 28, 4, 14,                 //   849:     check Inst[31:28] == 0xe
  OPC_CheckField, 19, 1, 0,                  //   853:     check Inst[19] == 0x0
  OPC_CheckField, 7, 1, 1,                   //   857:     check Inst[7] == 0x1
  OPC_Decode, 142, 14, 145, 1,               //   861:     decode to MVE_VSTRB16_pre using decoder 145
                                             //   861:    }
                                             //   861:    } // switch Inst[24]
                                             //   861:   }
  3, 0,                                      //   866:   case 0x3: {
  OPC_SwitchField, 24, 1,                    //   868:    switch Inst[24] {
  0, 37,                                     //   871:    case 0x0: {
  OPC_SwitchField, 28, 4,                    //   873:     switch Inst[31:28] {
  14, 15,                                    //   876:     case 0xe: {
  OPC_CheckPredicate, 31,                    //   878:      check predicate 31
  OPC_CheckField, 19, 1, 0,                  //   880:      check Inst[19] == 0x0
  OPC_CheckField, 7, 1, 1,                   //   884:      check Inst[7] == 0x1
  OPC_Decode, 228, 9, 144, 1,                //   888:      decode to MVE_VLDRBS16_post using decoder 144
                                             //   888:     }
  15, 0,                                     //   893:     case 0xf: {
  OPC_CheckPredicate, 31,                    //   895:      check predicate 31
  OPC_CheckField, 19, 1, 0,                  //   897:      check Inst[19] == 0x0
  OPC_CheckField, 7, 1, 1,                   //   901:      check Inst[7] == 0x1
  OPC_Decode, 236, 9, 144, 1,                //   905:      decode to MVE_VLDRBU16_post using decoder 144
                                             //   905:     }
                                             //   905:     } // switch Inst[31:28]
                                             //   905:    }
  1, 0,                                      //   910:    case 0x1: {
  OPC_SwitchField, 28, 4,                    //   912:     switch Inst[31:28] {
  14, 15,                                    //   915:     case 0xe: {
  OPC_CheckPredicate, 31,                    //   917:      check predicate 31
  OPC_CheckField, 19, 1, 0,                  //   919:      check Inst[19] == 0x0
  OPC_CheckField, 7, 1, 1,                   //   923:      check Inst[7] == 0x1
  OPC_Decode, 229, 9, 145, 1,                //   927:      decode to MVE_VLDRBS16_pre using decoder 145
                                             //   927:     }
  15, 0,                                     //   932:     case 0xf: {
  OPC_CheckPredicate, 31,                    //   934:      check predicate 31
  OPC_CheckField, 19, 1, 0,                  //   936:      check Inst[19] == 0x0
  OPC_CheckField, 7, 1, 1,                   //   940:      check Inst[7] == 0x1
  OPC_Decode, 237, 9, 145, 1,                //   944:      decode to MVE_VLDRBU16_pre using decoder 145
                                             //   944:     }
                                             //   944:     } // switch Inst[31:28]
                                             //   944:    }
                                             //   944:    } // switch Inst[24]
                                             //   944:   }
                                             //   944:   } // switch Inst[22:20]
                                             //   944:  }
  15, 175, 6,                                //   949:  case 0xf: {
  OPC_SwitchField, 20, 2,                    //   952:   switch Inst[21:20] {
  0, 231, 1,                                 //   955:   case 0x0: {
  OPC_SwitchField, 7, 1,                     //   958:    switch Inst[7] {
  0, 178, 1,                                 //   961:    case 0x0: {
  OPC_SwitchField, 24, 1,                    //   964:     switch Inst[24] {
  0, 133, 1,                                 //   967:     case 0x0: {
  OPC_SwitchField, 5, 2,                     //   970:      switch Inst[6:5] {
  0, 81,                                     //   973:      case 0x0: {
  OPC_SwitchField, 23, 1,                    //   975:       switch Inst[23] {
  0, 11,                                     //   978:       case 0x0: {
  OPC_CheckPredicate, 32,                    //   980:        check predicate 32
  OPC_CheckField, 28, 4, 14,                 //   982:        check Inst[31:28] == 0xe
  OPC_Decode, 143, 11, 146, 1,               //   986:        decode to MVE_VMOV_rr_q using decoder 146
                                             //   986:       }
  1, 0,                                      //   991:       case 0x1: {
  OPC_SwitchField, 0, 1,                     //   993:        switch Inst[0] {
  0, 37,                                     //   996:        case 0x0: {
  OPC_SwitchField, 4, 1,                     //   998:         switch Inst[4] {
  0, 15,                                     //  1001:         case 0x0: {
  OPC_CheckPredicate, 31,                    //  1003:          check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1005:          check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  //  1009:          check Inst[22] == 0x0
  OPC_Decode, 147, 14, 142, 1,               //  1013:          decode to MVE_VSTRB32_rq using decoder 142
                                             //  1013:         }
  1, 0,                                      //  1018:         case 0x1: {
  OPC_CheckPredicate, 31,                    //  1020:          check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1022:          check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  //  1026:          check Inst[22] == 0x0
  OPC_Decode, 162, 14, 142, 1,               //  1030:          decode to MVE_VSTRH32_rq_u using decoder 142
                                             //  1030:         }
                                             //  1030:         } // switch Inst[4]
                                             //  1030:        }
  1, 0,                                      //  1035:        case 0x1: {
  OPC_CheckPredicate, 31,                    //  1037:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1039:         check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  //  1043:         check Inst[22] == 0x0
  OPC_CheckField, 4, 1, 1,                   //  1047:         check Inst[4] == 0x1
  OPC_Decode, 161, 14, 142, 1,               //  1051:         decode to MVE_VSTRH32_rq using decoder 142
                                             //  1051:        }
                                             //  1051:        } // switch Inst[0]
                                             //  1051:       }
                                             //  1051:       } // switch Inst[23]
                                             //  1051:      }
  2, 0,                                      //  1056:      case 0x2: {
  OPC_SwitchField, 0, 1,                     //  1058:       switch Inst[0] {
  0, 19,                                     //  1061:       case 0x0: {
  OPC_CheckPredicate, 31,                    //  1063:        check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1065:        check Inst[31:28] == 0xe
  OPC_CheckField, 22, 2, 2,                  //  1069:        check Inst[23:22] == 0x2
  OPC_CheckField, 4, 1, 0,                   //  1073:        check Inst[4] == 0x0
  OPC_Decode, 169, 14, 142, 1,               //  1077:        decode to MVE_VSTRW32_rq_u using decoder 142
                                             //  1077:       }
  1, 0,                                      //  1082:       case 0x1: {
  OPC_CheckPredicate, 31,                    //  1084:        check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1086:        check Inst[31:28] == 0xe
  OPC_CheckField, 22, 2, 2,                  //  1090:        check Inst[23:22] == 0x2
  OPC_CheckField, 4, 1, 0,                   //  1094:        check Inst[4] == 0x0
  OPC_Decode, 168, 14, 142, 1,               //  1098:        decode to MVE_VSTRW32_rq using decoder 142
                                             //  1098:       }
                                             //  1098:       } // switch Inst[0]
                                             //  1098:      }
                                             //  1098:      } // switch Inst[6:5]
                                             //  1098:     }
  1, 0,                                      //  1103:     case 0x1: {
  OPC_SwitchField, 19, 1,                    //  1105:      switch Inst[19] {
  0, 15,                                     //  1108:      case 0x0: {
  OPC_CheckPredicate, 31,                    //  1110:       check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1112:       check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  //  1116:       check Inst[22] == 0x0
  OPC_Decode, 144, 14, 143, 1,               //  1120:       decode to MVE_VSTRB32 using decoder 143
                                             //  1120:      }
  1, 0,                                      //  1125:      case 0x1: {
  OPC_CheckPredicate, 31,                    //  1127:       check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1129:       check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  //  1133:       check Inst[22] == 0x0
  OPC_Decode, 158, 14, 147, 1,               //  1137:       decode to MVE_VSTRH32 using decoder 147
                                             //  1137:      }
                                             //  1137:      } // switch Inst[19]
                                             //  1137:     }
                                             //  1137:     } // switch Inst[24]
                                             //  1137:    }
  1, 0,                                      //  1142:    case 0x1: {
  OPC_SwitchField, 0, 1,                     //  1144:     switch Inst[0] {
  0, 19,                                     //  1147:     case 0x0: {
  OPC_CheckPredicate, 31,                    //  1149:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1151:      check Inst[31:28] == 0xe
  OPC_CheckField, 22, 3, 2,                  //  1155:      check Inst[24:22] == 0x2
  OPC_CheckField, 4, 3, 5,                   //  1159:      check Inst[6:4] == 0x5
  OPC_Decode, 155, 14, 142, 1,               //  1163:      decode to MVE_VSTRD64_rq_u using decoder 142
                                             //  1163:     }
  1, 0,                                      //  1168:     case 0x1: {
  OPC_CheckPredicate, 31,                    //  1170:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1172:      check Inst[31:28] == 0xe
  OPC_CheckField, 22, 3, 2,                  //  1176:      check Inst[24:22] == 0x2
  OPC_CheckField, 4, 3, 5,                   //  1180:      check Inst[6:4] == 0x5
  OPC_Decode, 154, 14, 142, 1,               //  1184:      decode to MVE_VSTRD64_rq using decoder 142
                                             //  1184:     }
                                             //  1184:     } // switch Inst[0]
                                             //  1184:    }
                                             //  1184:    } // switch Inst[7]
                                             //  1184:   }
  1, 177, 2,                                 //  1189:   case 0x1: {
  OPC_SwitchField, 7, 1,                     //  1192:    switch Inst[7] {
  0, 252, 1,                                 //  1195:    case 0x0: {
  OPC_SwitchField, 24, 1,                    //  1198:     switch Inst[24] {
  0, 179, 1,                                 //  1201:     case 0x0: {
  OPC_SwitchField, 5, 2,                     //  1204:      switch Inst[6:5] {
  0, 127,                                    //  1207:      case 0x0: {
  OPC_SwitchField, 23, 1,                    //  1209:       switch Inst[23] {
  0, 11,                                     //  1212:       case 0x0: {
  OPC_CheckPredicate, 32,                    //  1214:        check predicate 32
  OPC_CheckField, 28, 4, 14,                 //  1216:        check Inst[31:28] == 0xe
  OPC_Decode, 142, 11, 148, 1,               //  1220:        decode to MVE_VMOV_q_rr using decoder 148
                                             //  1220:       }
  1, 0,                                      //  1225:       case 0x1: {
  OPC_SwitchField, 0, 1,                     //  1227:        switch Inst[0] {
  0, 65,                                     //  1230:        case 0x0: {
  OPC_SwitchField, 4, 1,                     //  1232:         switch Inst[4] {
  0, 29,                                     //  1235:         case 0x0: {
  OPC_SwitchField, 28, 4,                    //  1237:          switch Inst[31:28] {
  14, 11,                                    //  1240:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  1242:           check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1244:           check Inst[22] == 0x0
  OPC_Decode, 234, 9, 142, 1,                //  1248:           decode to MVE_VLDRBS32_rq using decoder 142
                                             //  1248:          }
  15, 0,                                     //  1253:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  1255:           check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1257:           check Inst[22] == 0x0
  OPC_Decode, 242, 9, 142, 1,                //  1261:           decode to MVE_VLDRBU32_rq using decoder 142
                                             //  1261:          }
                                             //  1261:          } // switch Inst[31:28]
                                             //  1261:         }
  1, 0,                                      //  1266:         case 0x1: {
  OPC_SwitchField, 28, 4,                    //  1268:          switch Inst[31:28] {
  14, 11,                                    //  1271:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  1273:           check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1275:           check Inst[22] == 0x0
  OPC_Decode, 255, 9, 142, 1,                //  1279:           decode to MVE_VLDRHS32_rq_u using decoder 142
                                             //  1279:          }
  15, 0,                                     //  1284:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  1286:           check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1288:           check Inst[22] == 0x0
  OPC_Decode, 137, 10, 142, 1,               //  1292:           decode to MVE_VLDRHU32_rq_u using decoder 142
                                             //  1292:          }
                                             //  1292:          } // switch Inst[31:28]
                                             //  1292:         }
                                             //  1292:         } // switch Inst[4]
                                             //  1292:        }
  1, 0,                                      //  1297:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  1299:         switch Inst[31:28] {
  14, 15,                                    //  1302:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  1304:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1306:          check Inst[22] == 0x0
  OPC_CheckField, 4, 1, 1,                   //  1310:          check Inst[4] == 0x1
  OPC_Decode, 254, 9, 142, 1,                //  1314:          decode to MVE_VLDRHS32_rq using decoder 142
                                             //  1314:         }
  15, 0,                                     //  1319:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  1321:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1323:          check Inst[22] == 0x0
  OPC_CheckField, 4, 1, 1,                   //  1327:          check Inst[4] == 0x1
  OPC_Decode, 136, 10, 142, 1,               //  1331:          decode to MVE_VLDRHU32_rq using decoder 142
                                             //  1331:         }
                                             //  1331:         } // switch Inst[31:28]
                                             //  1331:        }
                                             //  1331:        } // switch Inst[0]
                                             //  1331:       }
                                             //  1331:       } // switch Inst[23]
                                             //  1331:      }
  2, 0,                                      //  1336:      case 0x2: {
  OPC_SwitchField, 0, 1,                     //  1338:       switch Inst[0] {
  0, 19,                                     //  1341:       case 0x0: {
  OPC_CheckPredicate, 31,                    //  1343:        check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1345:        check Inst[31:28] == 0xf
  OPC_CheckField, 22, 2, 2,                  //  1349:        check Inst[23:22] == 0x2
  OPC_CheckField, 4, 1, 0,                   //  1353:        check Inst[4] == 0x0
  OPC_Decode, 144, 10, 142, 1,               //  1357:        decode to MVE_VLDRWU32_rq_u using decoder 142
                                             //  1357:       }
  1, 0,                                      //  1362:       case 0x1: {
  OPC_CheckPredicate, 31,                    //  1364:        check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1366:        check Inst[31:28] == 0xf
  OPC_CheckField, 22, 2, 2,                  //  1370:        check Inst[23:22] == 0x2
  OPC_CheckField, 4, 1, 0,                   //  1374:        check Inst[4] == 0x0
  OPC_Decode, 143, 10, 142, 1,               //  1378:        decode to MVE_VLDRWU32_rq using decoder 142
                                             //  1378:       }
                                             //  1378:       } // switch Inst[0]
                                             //  1378:      }
                                             //  1378:      } // switch Inst[6:5]
                                             //  1378:     }
  1, 0,                                      //  1383:     case 0x1: {
  OPC_SwitchField, 19, 1,                    //  1385:      switch Inst[19] {
  0, 29,                                     //  1388:      case 0x0: {
  OPC_SwitchField, 28, 4,                    //  1390:       switch Inst[31:28] {
  14, 11,                                    //  1393:       case 0xe: {
  OPC_CheckPredicate, 31,                    //  1395:        check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1397:        check Inst[22] == 0x0
  OPC_Decode, 231, 9, 143, 1,                //  1401:        decode to MVE_VLDRBS32 using decoder 143
                                             //  1401:       }
  15, 0,                                     //  1406:       case 0xf: {
  OPC_CheckPredicate, 31,                    //  1408:        check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1410:        check Inst[22] == 0x0
  OPC_Decode, 239, 9, 143, 1,                //  1414:        decode to MVE_VLDRBU32 using decoder 143
                                             //  1414:       }
                                             //  1414:       } // switch Inst[31:28]
                                             //  1414:      }
  1, 0,                                      //  1419:      case 0x1: {
  OPC_SwitchField, 28, 4,                    //  1421:       switch Inst[31:28] {
  14, 11,                                    //  1424:       case 0xe: {
  OPC_CheckPredicate, 31,                    //  1426:        check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1428:        check Inst[22] == 0x0
  OPC_Decode, 251, 9, 147, 1,                //  1432:        decode to MVE_VLDRHS32 using decoder 147
                                             //  1432:       }
  15, 0,                                     //  1437:       case 0xf: {
  OPC_CheckPredicate, 31,                    //  1439:        check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1441:        check Inst[22] == 0x0
  OPC_Decode, 133, 10, 147, 1,               //  1445:        decode to MVE_VLDRHU32 using decoder 147
                                             //  1445:       }
                                             //  1445:       } // switch Inst[31:28]
                                             //  1445:      }
                                             //  1445:      } // switch Inst[19]
                                             //  1445:     }
                                             //  1445:     } // switch Inst[24]
                                             //  1445:    }
  1, 0,                                      //  1450:    case 0x1: {
  OPC_SwitchField, 0, 1,                     //  1452:     switch Inst[0] {
  0, 19,                                     //  1455:     case 0x0: {
  OPC_CheckPredicate, 31,                    //  1457:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1459:      check Inst[31:28] == 0xf
  OPC_CheckField, 22, 3, 2,                  //  1463:      check Inst[24:22] == 0x2
  OPC_CheckField, 4, 3, 5,                   //  1467:      check Inst[6:4] == 0x5
  OPC_Decode, 250, 9, 142, 1,                //  1471:      decode to MVE_VLDRDU64_rq_u using decoder 142
                                             //  1471:     }
  1, 0,                                      //  1476:     case 0x1: {
  OPC_CheckPredicate, 31,                    //  1478:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1480:      check Inst[31:28] == 0xf
  OPC_CheckField, 22, 3, 2,                  //  1484:      check Inst[24:22] == 0x2
  OPC_CheckField, 4, 3, 5,                   //  1488:      check Inst[6:4] == 0x5
  OPC_Decode, 249, 9, 142, 1,                //  1492:      decode to MVE_VLDRDU64_rq using decoder 142
                                             //  1492:     }
                                             //  1492:     } // switch Inst[0]
                                             //  1492:    }
                                             //  1492:    } // switch Inst[7]
                                             //  1492:   }
  2, 97,                                     //  1497:   case 0x2: {
  OPC_SwitchField, 19, 1,                    //  1499:    switch Inst[19] {
  0, 45,                                     //  1502:    case 0x0: {
  OPC_SwitchField, 24, 1,                    //  1504:     switch Inst[24] {
  0, 19,                                     //  1507:     case 0x0: {
  OPC_CheckPredicate, 31,                    //  1509:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1511:      check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  //  1515:      check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1519:      check Inst[7] == 0x0
  OPC_Decode, 145, 14, 144, 1,               //  1523:      decode to MVE_VSTRB32_post using decoder 144
                                             //  1523:     }
  1, 0,                                      //  1528:     case 0x1: {
  OPC_CheckPredicate, 31,                    //  1530:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1532:      check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  //  1536:      check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1540:      check Inst[7] == 0x0
  OPC_Decode, 146, 14, 145, 1,               //  1544:      decode to MVE_VSTRB32_pre using decoder 145
                                             //  1544:     }
                                             //  1544:     } // switch Inst[24]
                                             //  1544:    }
  1, 0,                                      //  1549:    case 0x1: {
  OPC_SwitchField, 24, 1,                    //  1551:     switch Inst[24] {
  0, 19,                                     //  1554:     case 0x0: {
  OPC_CheckPredicate, 31,                    //  1556:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1558:      check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  //  1562:      check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1566:      check Inst[7] == 0x0
  OPC_Decode, 159, 14, 149, 1,               //  1570:      decode to MVE_VSTRH32_post using decoder 149
                                             //  1570:     }
  1, 0,                                      //  1575:     case 0x1: {
  OPC_CheckPredicate, 31,                    //  1577:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  1579:      check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  //  1583:      check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1587:      check Inst[7] == 0x0
  OPC_Decode, 160, 14, 150, 1,               //  1591:      decode to MVE_VSTRH32_pre using decoder 150
                                             //  1591:     }
                                             //  1591:     } // switch Inst[24]
                                             //  1591:    }
                                             //  1591:    } // switch Inst[19]
                                             //  1591:   }
  3, 0,                                      //  1596:   case 0x3: {
  OPC_SwitchField, 19, 1,                    //  1598:    switch Inst[19] {
  0, 81,                                     //  1601:    case 0x0: {
  OPC_SwitchField, 24, 1,                    //  1603:     switch Inst[24] {
  0, 37,                                     //  1606:     case 0x0: {
  OPC_SwitchField, 28, 4,                    //  1608:      switch Inst[31:28] {
  14, 15,                                    //  1611:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  1613:       check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1615:       check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1619:       check Inst[7] == 0x0
  OPC_Decode, 232, 9, 144, 1,                //  1623:       decode to MVE_VLDRBS32_post using decoder 144
                                             //  1623:      }
  15, 0,                                     //  1628:      case 0xf: {
  OPC_CheckPredicate, 31,                    //  1630:       check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1632:       check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1636:       check Inst[7] == 0x0
  OPC_Decode, 240, 9, 144, 1,                //  1640:       decode to MVE_VLDRBU32_post using decoder 144
                                             //  1640:      }
                                             //  1640:      } // switch Inst[31:28]
                                             //  1640:     }
  1, 0,                                      //  1645:     case 0x1: {
  OPC_SwitchField, 28, 4,                    //  1647:      switch Inst[31:28] {
  14, 15,                                    //  1650:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  1652:       check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1654:       check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1658:       check Inst[7] == 0x0
  OPC_Decode, 233, 9, 145, 1,                //  1662:       decode to MVE_VLDRBS32_pre using decoder 145
                                             //  1662:      }
  15, 0,                                     //  1667:      case 0xf: {
  OPC_CheckPredicate, 31,                    //  1669:       check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1671:       check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1675:       check Inst[7] == 0x0
  OPC_Decode, 241, 9, 145, 1,                //  1679:       decode to MVE_VLDRBU32_pre using decoder 145
                                             //  1679:      }
                                             //  1679:      } // switch Inst[31:28]
                                             //  1679:     }
                                             //  1679:     } // switch Inst[24]
                                             //  1679:    }
  1, 0,                                      //  1684:    case 0x1: {
  OPC_SwitchField, 24, 1,                    //  1686:     switch Inst[24] {
  0, 37,                                     //  1689:     case 0x0: {
  OPC_SwitchField, 28, 4,                    //  1691:      switch Inst[31:28] {
  14, 15,                                    //  1694:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  1696:       check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1698:       check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1702:       check Inst[7] == 0x0
  OPC_Decode, 252, 9, 149, 1,                //  1706:       decode to MVE_VLDRHS32_post using decoder 149
                                             //  1706:      }
  15, 0,                                     //  1711:      case 0xf: {
  OPC_CheckPredicate, 31,                    //  1713:       check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1715:       check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1719:       check Inst[7] == 0x0
  OPC_Decode, 134, 10, 149, 1,               //  1723:       decode to MVE_VLDRHU32_post using decoder 149
                                             //  1723:      }
                                             //  1723:      } // switch Inst[31:28]
                                             //  1723:     }
  1, 0,                                      //  1728:     case 0x1: {
  OPC_SwitchField, 28, 4,                    //  1730:      switch Inst[31:28] {
  14, 15,                                    //  1733:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  1735:       check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1737:       check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1741:       check Inst[7] == 0x0
  OPC_Decode, 253, 9, 150, 1,                //  1745:       decode to MVE_VLDRHS32_pre using decoder 150
                                             //  1745:      }
  15, 0,                                     //  1750:      case 0xf: {
  OPC_CheckPredicate, 31,                    //  1752:       check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  1754:       check Inst[22] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  1758:       check Inst[7] == 0x0
  OPC_Decode, 135, 10, 150, 1,               //  1762:       decode to MVE_VLDRHU32_pre using decoder 150
                                             //  1762:      }
                                             //  1762:      } // switch Inst[31:28]
                                             //  1762:     }
                                             //  1762:     } // switch Inst[24]
                                             //  1762:    }
                                             //  1762:    } // switch Inst[19]
                                             //  1762:   }
                                             //  1762:   } // switch Inst[21:20]
                                             //  1762:  }
  30, 148, 8,                                //  1767:  case 0x1e: {
  OPC_SwitchField, 20, 3,                    //  1770:   switch Inst[22:20] {
  0, 140, 2,                                 //  1773:   case 0x0: {
  OPC_SwitchField, 7, 1,                     //  1776:    switch Inst[7] {
  0, 137, 1,                                 //  1779:    case 0x0: {
  OPC_SwitchField, 24, 1,                    //  1782:     switch Inst[24] {
  0, 105,                                    //  1785:     case 0x0: {
  OPC_SwitchField, 0, 7,                     //  1787:      switch Inst[6:0] {
  0, 15,                                     //  1790:      case 0x0: {
  OPC_CheckPredicate, 31,                    //  1792:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1794:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  1798:       check Inst[23] == 0x1
  OPC_Decode, 236, 13, 151, 1,               //  1802:       decode to MVE_VST20_8 using decoder 151
                                             //  1802:      }
  1, 15,                                     //  1807:      case 0x1: {
  OPC_CheckPredicate, 31,                    //  1809:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1811:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  1815:       check Inst[23] == 0x1
  OPC_Decode, 248, 13, 152, 1,               //  1819:       decode to MVE_VST40_8 using decoder 152
                                             //  1819:      }
  32, 15,                                    //  1824:      case 0x20: {
  OPC_CheckPredicate, 31,                    //  1826:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1828:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  1832:       check Inst[23] == 0x1
  OPC_Decode, 242, 13, 151, 1,               //  1836:       decode to MVE_VST21_8 using decoder 151
                                             //  1836:      }
  33, 15,                                    //  1841:      case 0x21: {
  OPC_CheckPredicate, 31,                    //  1843:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1845:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  1849:       check Inst[23] == 0x1
  OPC_Decode, 254, 13, 152, 1,               //  1853:       decode to MVE_VST41_8 using decoder 152
                                             //  1853:      }
  65, 15,                                    //  1858:      case 0x41: {
  OPC_CheckPredicate, 31,                    //  1860:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1862:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  1866:       check Inst[23] == 0x1
  OPC_Decode, 132, 14, 152, 1,               //  1870:       decode to MVE_VST42_8 using decoder 152
                                             //  1870:      }
  97, 0,                                     //  1875:      case 0x61: {
  OPC_CheckPredicate, 31,                    //  1877:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1879:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  1883:       check Inst[23] == 0x1
  OPC_Decode, 138, 14, 152, 1,               //  1887:       decode to MVE_VST43_8 using decoder 152
                                             //  1887:      }
                                             //  1887:      } // switch Inst[6:0]
                                             //  1887:     }
  1, 0,                                      //  1892:     case 0x1: {
  OPC_SwitchField, 28, 4,                    //  1894:      switch Inst[31:28] {
  14, 7,                                     //  1897:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  1899:       check predicate 31
  OPC_Decode, 149, 14, 153, 1,               //  1901:       decode to MVE_VSTRBU8 using decoder 153
                                             //  1901:      }
  15, 0,                                     //  1906:      case 0xf: {
  OPC_CheckPredicate, 31,                    //  1908:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  1910:       check Inst[16] == 0x0
  OPC_Decode, 166, 14, 154, 1,               //  1914:       decode to MVE_VSTRW32_qi using decoder 154
                                             //  1914:      }
                                             //  1914:      } // switch Inst[31:28]
                                             //  1914:     }
                                             //  1914:     } // switch Inst[24]
                                             //  1914:    }
  1, 0,                                      //  1919:    case 0x1: {
  OPC_SwitchField, 24, 1,                    //  1921:     switch Inst[24] {
  0, 105,                                    //  1924:     case 0x0: {
  OPC_SwitchField, 0, 7,                     //  1926:      switch Inst[6:0] {
  0, 15,                                     //  1929:      case 0x0: {
  OPC_CheckPredicate, 31,                    //  1931:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1933:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  1937:       check Inst[23] == 0x1
  OPC_Decode, 232, 13, 151, 1,               //  1941:       decode to MVE_VST20_16 using decoder 151
                                             //  1941:      }
  1, 15,                                     //  1946:      case 0x1: {
  OPC_CheckPredicate, 31,                    //  1948:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1950:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  1954:       check Inst[23] == 0x1
  OPC_Decode, 244, 13, 152, 1,               //  1958:       decode to MVE_VST40_16 using decoder 152
                                             //  1958:      }
  32, 15,                                    //  1963:      case 0x20: {
  OPC_CheckPredicate, 31,                    //  1965:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1967:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  1971:       check Inst[23] == 0x1
  OPC_Decode, 238, 13, 151, 1,               //  1975:       decode to MVE_VST21_16 using decoder 151
                                             //  1975:      }
  33, 15,                                    //  1980:      case 0x21: {
  OPC_CheckPredicate, 31,                    //  1982:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  1984:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  1988:       check Inst[23] == 0x1
  OPC_Decode, 250, 13, 152, 1,               //  1992:       decode to MVE_VST41_16 using decoder 152
                                             //  1992:      }
  65, 15,                                    //  1997:      case 0x41: {
  OPC_CheckPredicate, 31,                    //  1999:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2001:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2005:       check Inst[23] == 0x1
  OPC_Decode, 128, 14, 152, 1,               //  2009:       decode to MVE_VST42_16 using decoder 152
                                             //  2009:      }
  97, 0,                                     //  2014:      case 0x61: {
  OPC_CheckPredicate, 31,                    //  2016:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2018:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2022:       check Inst[23] == 0x1
  OPC_Decode, 134, 14, 152, 1,               //  2026:       decode to MVE_VST43_16 using decoder 152
                                             //  2026:      }
                                             //  2026:      } // switch Inst[6:0]
                                             //  2026:     }
  1, 0,                                      //  2031:     case 0x1: {
  OPC_CheckPredicate, 31,                    //  2033:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  2035:      check Inst[31:28] == 0xe
  OPC_Decode, 163, 14, 155, 1,               //  2039:      decode to MVE_VSTRHU16 using decoder 155
                                             //  2039:     }
                                             //  2039:     } // switch Inst[24]
                                             //  2039:    }
                                             //  2039:    } // switch Inst[7]
                                             //  2039:   }
  1, 140, 2,                                 //  2044:   case 0x1: {
  OPC_SwitchField, 7, 1,                     //  2047:    switch Inst[7] {
  0, 137, 1,                                 //  2050:    case 0x0: {
  OPC_SwitchField, 24, 1,                    //  2053:     switch Inst[24] {
  0, 105,                                    //  2056:     case 0x0: {
  OPC_SwitchField, 0, 7,                     //  2058:      switch Inst[6:0] {
  0, 15,                                     //  2061:      case 0x0: {
  OPC_CheckPredicate, 31,                    //  2063:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2065:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2069:       check Inst[23] == 0x1
  OPC_Decode, 195, 9, 156, 1,                //  2073:       decode to MVE_VLD20_8 using decoder 156
                                             //  2073:      }
  1, 15,                                     //  2078:      case 0x1: {
  OPC_CheckPredicate, 31,                    //  2080:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2082:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2086:       check Inst[23] == 0x1
  OPC_Decode, 207, 9, 157, 1,                //  2090:       decode to MVE_VLD40_8 using decoder 157
                                             //  2090:      }
  32, 15,                                    //  2095:      case 0x20: {
  OPC_CheckPredicate, 31,                    //  2097:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2099:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2103:       check Inst[23] == 0x1
  OPC_Decode, 201, 9, 156, 1,                //  2107:       decode to MVE_VLD21_8 using decoder 156
                                             //  2107:      }
  33, 15,                                    //  2112:      case 0x21: {
  OPC_CheckPredicate, 31,                    //  2114:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2116:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2120:       check Inst[23] == 0x1
  OPC_Decode, 213, 9, 157, 1,                //  2124:       decode to MVE_VLD41_8 using decoder 157
                                             //  2124:      }
  65, 15,                                    //  2129:      case 0x41: {
  OPC_CheckPredicate, 31,                    //  2131:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2133:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2137:       check Inst[23] == 0x1
  OPC_Decode, 219, 9, 157, 1,                //  2141:       decode to MVE_VLD42_8 using decoder 157
                                             //  2141:      }
  97, 0,                                     //  2146:      case 0x61: {
  OPC_CheckPredicate, 31,                    //  2148:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2150:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2154:       check Inst[23] == 0x1
  OPC_Decode, 225, 9, 157, 1,                //  2158:       decode to MVE_VLD43_8 using decoder 157
                                             //  2158:      }
                                             //  2158:      } // switch Inst[6:0]
                                             //  2158:     }
  1, 0,                                      //  2163:     case 0x1: {
  OPC_SwitchField, 28, 4,                    //  2165:      switch Inst[31:28] {
  14, 7,                                     //  2168:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  2170:       check predicate 31
  OPC_Decode, 243, 9, 153, 1,                //  2172:       decode to MVE_VLDRBU8 using decoder 153
                                             //  2172:      }
  15, 0,                                     //  2177:      case 0xf: {
  OPC_CheckPredicate, 31,                    //  2179:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  2181:       check Inst[16] == 0x0
  OPC_Decode, 141, 10, 154, 1,               //  2185:       decode to MVE_VLDRWU32_qi using decoder 154
                                             //  2185:      }
                                             //  2185:      } // switch Inst[31:28]
                                             //  2185:     }
                                             //  2185:     } // switch Inst[24]
                                             //  2185:    }
  1, 0,                                      //  2190:    case 0x1: {
  OPC_SwitchField, 24, 1,                    //  2192:     switch Inst[24] {
  0, 105,                                    //  2195:     case 0x0: {
  OPC_SwitchField, 0, 7,                     //  2197:      switch Inst[6:0] {
  0, 15,                                     //  2200:      case 0x0: {
  OPC_CheckPredicate, 31,                    //  2202:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2204:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2208:       check Inst[23] == 0x1
  OPC_Decode, 191, 9, 156, 1,                //  2212:       decode to MVE_VLD20_16 using decoder 156
                                             //  2212:      }
  1, 15,                                     //  2217:      case 0x1: {
  OPC_CheckPredicate, 31,                    //  2219:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2221:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2225:       check Inst[23] == 0x1
  OPC_Decode, 203, 9, 157, 1,                //  2229:       decode to MVE_VLD40_16 using decoder 157
                                             //  2229:      }
  32, 15,                                    //  2234:      case 0x20: {
  OPC_CheckPredicate, 31,                    //  2236:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2238:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2242:       check Inst[23] == 0x1
  OPC_Decode, 197, 9, 156, 1,                //  2246:       decode to MVE_VLD21_16 using decoder 156
                                             //  2246:      }
  33, 15,                                    //  2251:      case 0x21: {
  OPC_CheckPredicate, 31,                    //  2253:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2255:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2259:       check Inst[23] == 0x1
  OPC_Decode, 209, 9, 157, 1,                //  2263:       decode to MVE_VLD41_16 using decoder 157
                                             //  2263:      }
  65, 15,                                    //  2268:      case 0x41: {
  OPC_CheckPredicate, 31,                    //  2270:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2272:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2276:       check Inst[23] == 0x1
  OPC_Decode, 215, 9, 157, 1,                //  2280:       decode to MVE_VLD42_16 using decoder 157
                                             //  2280:      }
  97, 0,                                     //  2285:      case 0x61: {
  OPC_CheckPredicate, 31,                    //  2287:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2289:       check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2293:       check Inst[23] == 0x1
  OPC_Decode, 221, 9, 157, 1,                //  2297:       decode to MVE_VLD43_16 using decoder 157
                                             //  2297:      }
                                             //  2297:      } // switch Inst[6:0]
                                             //  2297:     }
  1, 0,                                      //  2302:     case 0x1: {
  OPC_CheckPredicate, 31,                    //  2304:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  2306:      check Inst[31:28] == 0xe
  OPC_Decode, 128, 10, 155, 1,               //  2310:      decode to MVE_VLDRHU16 using decoder 155
                                             //  2310:     }
                                             //  2310:     } // switch Inst[24]
                                             //  2310:    }
                                             //  2310:    } // switch Inst[7]
                                             //  2310:   }
  2, 247, 1,                                 //  2315:   case 0x2: {
  OPC_SwitchField, 7, 1,                     //  2318:    switch Inst[7] {
  0, 127,                                    //  2321:    case 0x0: {
  OPC_SwitchField, 24, 1,                    //  2323:     switch Inst[24] {
  0, 95,                                     //  2326:     case 0x0: {
  OPC_SwitchField, 28, 4,                    //  2328:      switch Inst[31:28] {
  14, 7,                                     //  2331:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  2333:       check predicate 31
  OPC_Decode, 150, 14, 158, 1,               //  2335:       decode to MVE_VSTRBU8_post using decoder 158
                                             //  2335:      }
  15, 0,                                     //  2340:      case 0xf: {
  OPC_SwitchField, 0, 7,                     //  2342:       switch Inst[6:0] {
  0, 11,                                     //  2345:       case 0x0: {
  OPC_CheckPredicate, 31,                    //  2347:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2349:        check Inst[23] == 0x1
  OPC_Decode, 237, 13, 159, 1,               //  2353:        decode to MVE_VST20_8_wb using decoder 159
                                             //  2353:       }
  1, 11,                                     //  2358:       case 0x1: {
  OPC_CheckPredicate, 31,                    //  2360:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2362:        check Inst[23] == 0x1
  OPC_Decode, 249, 13, 160, 1,               //  2366:        decode to MVE_VST40_8_wb using decoder 160
                                             //  2366:       }
  32, 11,                                    //  2371:       case 0x20: {
  OPC_CheckPredicate, 31,                    //  2373:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2375:        check Inst[23] == 0x1
  OPC_Decode, 243, 13, 159, 1,               //  2379:        decode to MVE_VST21_8_wb using decoder 159
                                             //  2379:       }
  33, 11,                                    //  2384:       case 0x21: {
  OPC_CheckPredicate, 31,                    //  2386:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2388:        check Inst[23] == 0x1
  OPC_Decode, 255, 13, 160, 1,               //  2392:        decode to MVE_VST41_8_wb using decoder 160
                                             //  2392:       }
  65, 11,                                    //  2397:       case 0x41: {
  OPC_CheckPredicate, 31,                    //  2399:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2401:        check Inst[23] == 0x1
  OPC_Decode, 133, 14, 160, 1,               //  2405:        decode to MVE_VST42_8_wb using decoder 160
                                             //  2405:       }
  97, 0,                                     //  2410:       case 0x61: {
  OPC_CheckPredicate, 31,                    //  2412:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2414:        check Inst[23] == 0x1
  OPC_Decode, 139, 14, 160, 1,               //  2418:        decode to MVE_VST43_8_wb using decoder 160
                                             //  2418:       }
                                             //  2418:       } // switch Inst[6:0]
                                             //  2418:      }
                                             //  2418:      } // switch Inst[31:28]
                                             //  2418:     }
  1, 0,                                      //  2423:     case 0x1: {
  OPC_SwitchField, 28, 4,                    //  2425:      switch Inst[31:28] {
  14, 7,                                     //  2428:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  2430:       check predicate 31
  OPC_Decode, 151, 14, 161, 1,               //  2432:       decode to MVE_VSTRBU8_pre using decoder 161
                                             //  2432:      }
  15, 0,                                     //  2437:      case 0xf: {
  OPC_CheckPredicate, 31,                    //  2439:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  2441:       check Inst[16] == 0x0
  OPC_Decode, 167, 14, 162, 1,               //  2445:       decode to MVE_VSTRW32_qi_pre using decoder 162
                                             //  2445:      }
                                             //  2445:      } // switch Inst[31:28]
                                             //  2445:     }
                                             //  2445:     } // switch Inst[24]
                                             //  2445:    }
  1, 0,                                      //  2450:    case 0x1: {
  OPC_SwitchField, 24, 1,                    //  2452:     switch Inst[24] {
  0, 95,                                     //  2455:     case 0x0: {
  OPC_SwitchField, 28, 4,                    //  2457:      switch Inst[31:28] {
  14, 7,                                     //  2460:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  2462:       check predicate 31
  OPC_Decode, 164, 14, 163, 1,               //  2464:       decode to MVE_VSTRHU16_post using decoder 163
                                             //  2464:      }
  15, 0,                                     //  2469:      case 0xf: {
  OPC_SwitchField, 0, 7,                     //  2471:       switch Inst[6:0] {
  0, 11,                                     //  2474:       case 0x0: {
  OPC_CheckPredicate, 31,                    //  2476:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2478:        check Inst[23] == 0x1
  OPC_Decode, 233, 13, 159, 1,               //  2482:        decode to MVE_VST20_16_wb using decoder 159
                                             //  2482:       }
  1, 11,                                     //  2487:       case 0x1: {
  OPC_CheckPredicate, 31,                    //  2489:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2491:        check Inst[23] == 0x1
  OPC_Decode, 245, 13, 160, 1,               //  2495:        decode to MVE_VST40_16_wb using decoder 160
                                             //  2495:       }
  32, 11,                                    //  2500:       case 0x20: {
  OPC_CheckPredicate, 31,                    //  2502:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2504:        check Inst[23] == 0x1
  OPC_Decode, 239, 13, 159, 1,               //  2508:        decode to MVE_VST21_16_wb using decoder 159
                                             //  2508:       }
  33, 11,                                    //  2513:       case 0x21: {
  OPC_CheckPredicate, 31,                    //  2515:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2517:        check Inst[23] == 0x1
  OPC_Decode, 251, 13, 160, 1,               //  2521:        decode to MVE_VST41_16_wb using decoder 160
                                             //  2521:       }
  65, 11,                                    //  2526:       case 0x41: {
  OPC_CheckPredicate, 31,                    //  2528:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2530:        check Inst[23] == 0x1
  OPC_Decode, 129, 14, 160, 1,               //  2534:        decode to MVE_VST42_16_wb using decoder 160
                                             //  2534:       }
  97, 0,                                     //  2539:       case 0x61: {
  OPC_CheckPredicate, 31,                    //  2541:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2543:        check Inst[23] == 0x1
  OPC_Decode, 135, 14, 160, 1,               //  2547:        decode to MVE_VST43_16_wb using decoder 160
                                             //  2547:       }
                                             //  2547:       } // switch Inst[6:0]
                                             //  2547:      }
                                             //  2547:      } // switch Inst[31:28]
                                             //  2547:     }
  1, 0,                                      //  2552:     case 0x1: {
  OPC_CheckPredicate, 31,                    //  2554:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  2556:      check Inst[31:28] == 0xe
  OPC_Decode, 165, 14, 164, 1,               //  2560:      decode to MVE_VSTRHU16_pre using decoder 164
                                             //  2560:     }
                                             //  2560:     } // switch Inst[24]
                                             //  2560:    }
                                             //  2560:    } // switch Inst[7]
                                             //  2560:   }
  3, 0,                                      //  2565:   case 0x3: {
  OPC_SwitchField, 7, 1,                     //  2567:    switch Inst[7] {
  0, 127,                                    //  2570:    case 0x0: {
  OPC_SwitchField, 24, 1,                    //  2572:     switch Inst[24] {
  0, 95,                                     //  2575:     case 0x0: {
  OPC_SwitchField, 28, 4,                    //  2577:      switch Inst[31:28] {
  14, 7,                                     //  2580:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  2582:       check predicate 31
  OPC_Decode, 244, 9, 158, 1,                //  2584:       decode to MVE_VLDRBU8_post using decoder 158
                                             //  2584:      }
  15, 0,                                     //  2589:      case 0xf: {
  OPC_SwitchField, 0, 7,                     //  2591:       switch Inst[6:0] {
  0, 11,                                     //  2594:       case 0x0: {
  OPC_CheckPredicate, 31,                    //  2596:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2598:        check Inst[23] == 0x1
  OPC_Decode, 196, 9, 165, 1,                //  2602:        decode to MVE_VLD20_8_wb using decoder 165
                                             //  2602:       }
  1, 11,                                     //  2607:       case 0x1: {
  OPC_CheckPredicate, 31,                    //  2609:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2611:        check Inst[23] == 0x1
  OPC_Decode, 208, 9, 166, 1,                //  2615:        decode to MVE_VLD40_8_wb using decoder 166
                                             //  2615:       }
  32, 11,                                    //  2620:       case 0x20: {
  OPC_CheckPredicate, 31,                    //  2622:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2624:        check Inst[23] == 0x1
  OPC_Decode, 202, 9, 165, 1,                //  2628:        decode to MVE_VLD21_8_wb using decoder 165
                                             //  2628:       }
  33, 11,                                    //  2633:       case 0x21: {
  OPC_CheckPredicate, 31,                    //  2635:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2637:        check Inst[23] == 0x1
  OPC_Decode, 214, 9, 166, 1,                //  2641:        decode to MVE_VLD41_8_wb using decoder 166
                                             //  2641:       }
  65, 11,                                    //  2646:       case 0x41: {
  OPC_CheckPredicate, 31,                    //  2648:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2650:        check Inst[23] == 0x1
  OPC_Decode, 220, 9, 166, 1,                //  2654:        decode to MVE_VLD42_8_wb using decoder 166
                                             //  2654:       }
  97, 0,                                     //  2659:       case 0x61: {
  OPC_CheckPredicate, 31,                    //  2661:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2663:        check Inst[23] == 0x1
  OPC_Decode, 226, 9, 166, 1,                //  2667:        decode to MVE_VLD43_8_wb using decoder 166
                                             //  2667:       }
                                             //  2667:       } // switch Inst[6:0]
                                             //  2667:      }
                                             //  2667:      } // switch Inst[31:28]
                                             //  2667:     }
  1, 0,                                      //  2672:     case 0x1: {
  OPC_SwitchField, 28, 4,                    //  2674:      switch Inst[31:28] {
  14, 7,                                     //  2677:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  2679:       check predicate 31
  OPC_Decode, 245, 9, 161, 1,                //  2681:       decode to MVE_VLDRBU8_pre using decoder 161
                                             //  2681:      }
  15, 0,                                     //  2686:      case 0xf: {
  OPC_CheckPredicate, 31,                    //  2688:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  2690:       check Inst[16] == 0x0
  OPC_Decode, 142, 10, 162, 1,               //  2694:       decode to MVE_VLDRWU32_qi_pre using decoder 162
                                             //  2694:      }
                                             //  2694:      } // switch Inst[31:28]
                                             //  2694:     }
                                             //  2694:     } // switch Inst[24]
                                             //  2694:    }
  1, 0,                                      //  2699:    case 0x1: {
  OPC_SwitchField, 24, 1,                    //  2701:     switch Inst[24] {
  0, 95,                                     //  2704:     case 0x0: {
  OPC_SwitchField, 28, 4,                    //  2706:      switch Inst[31:28] {
  14, 7,                                     //  2709:      case 0xe: {
  OPC_CheckPredicate, 31,                    //  2711:       check predicate 31
  OPC_Decode, 129, 10, 163, 1,               //  2713:       decode to MVE_VLDRHU16_post using decoder 163
                                             //  2713:      }
  15, 0,                                     //  2718:      case 0xf: {
  OPC_SwitchField, 0, 7,                     //  2720:       switch Inst[6:0] {
  0, 11,                                     //  2723:       case 0x0: {
  OPC_CheckPredicate, 31,                    //  2725:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2727:        check Inst[23] == 0x1
  OPC_Decode, 192, 9, 165, 1,                //  2731:        decode to MVE_VLD20_16_wb using decoder 165
                                             //  2731:       }
  1, 11,                                     //  2736:       case 0x1: {
  OPC_CheckPredicate, 31,                    //  2738:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2740:        check Inst[23] == 0x1
  OPC_Decode, 204, 9, 166, 1,                //  2744:        decode to MVE_VLD40_16_wb using decoder 166
                                             //  2744:       }
  32, 11,                                    //  2749:       case 0x20: {
  OPC_CheckPredicate, 31,                    //  2751:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2753:        check Inst[23] == 0x1
  OPC_Decode, 198, 9, 165, 1,                //  2757:        decode to MVE_VLD21_16_wb using decoder 165
                                             //  2757:       }
  33, 11,                                    //  2762:       case 0x21: {
  OPC_CheckPredicate, 31,                    //  2764:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2766:        check Inst[23] == 0x1
  OPC_Decode, 210, 9, 166, 1,                //  2770:        decode to MVE_VLD41_16_wb using decoder 166
                                             //  2770:       }
  65, 11,                                    //  2775:       case 0x41: {
  OPC_CheckPredicate, 31,                    //  2777:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2779:        check Inst[23] == 0x1
  OPC_Decode, 216, 9, 166, 1,                //  2783:        decode to MVE_VLD42_16_wb using decoder 166
                                             //  2783:       }
  97, 0,                                     //  2788:       case 0x61: {
  OPC_CheckPredicate, 31,                    //  2790:        check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  2792:        check Inst[23] == 0x1
  OPC_Decode, 222, 9, 166, 1,                //  2796:        decode to MVE_VLD43_16_wb using decoder 166
                                             //  2796:       }
                                             //  2796:       } // switch Inst[6:0]
                                             //  2796:      }
                                             //  2796:      } // switch Inst[31:28]
                                             //  2796:     }
  1, 0,                                      //  2801:     case 0x1: {
  OPC_CheckPredicate, 31,                    //  2803:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  2805:      check Inst[31:28] == 0xe
  OPC_Decode, 130, 10, 164, 1,               //  2809:      decode to MVE_VLDRHU16_pre using decoder 164
                                             //  2809:     }
                                             //  2809:     } // switch Inst[24]
                                             //  2809:    }
                                             //  2809:    } // switch Inst[7]
                                             //  2809:   }
                                             //  2809:   } // switch Inst[22:20]
                                             //  2809:  }
  31, 0,                                     //  2814:  case 0x1f: {
  OPC_SwitchField, 20, 3,                    //  2816:   switch Inst[22:20] {
  0, 145, 1,                                 //  2819:   case 0x0: {
  OPC_SwitchField, 24, 1,                    //  2822:    switch Inst[24] {
  0, 105,                                    //  2825:    case 0x0: {
  OPC_SwitchField, 0, 8,                     //  2827:     switch Inst[7:0] {
  0, 15,                                     //  2830:     case 0x0: {
  OPC_CheckPredicate, 31,                    //  2832:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2834:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2838:      check Inst[23] == 0x1
  OPC_Decode, 234, 13, 151, 1,               //  2842:      decode to MVE_VST20_32 using decoder 151
                                             //  2842:     }
  1, 15,                                     //  2847:     case 0x1: {
  OPC_CheckPredicate, 31,                    //  2849:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2851:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2855:      check Inst[23] == 0x1
  OPC_Decode, 246, 13, 152, 1,               //  2859:      decode to MVE_VST40_32 using decoder 152
                                             //  2859:     }
  32, 15,                                    //  2864:     case 0x20: {
  OPC_CheckPredicate, 31,                    //  2866:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2868:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2872:      check Inst[23] == 0x1
  OPC_Decode, 240, 13, 151, 1,               //  2876:      decode to MVE_VST21_32 using decoder 151
                                             //  2876:     }
  33, 15,                                    //  2881:     case 0x21: {
  OPC_CheckPredicate, 31,                    //  2883:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2885:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2889:      check Inst[23] == 0x1
  OPC_Decode, 252, 13, 152, 1,               //  2893:      decode to MVE_VST41_32 using decoder 152
                                             //  2893:     }
  65, 15,                                    //  2898:     case 0x41: {
  OPC_CheckPredicate, 31,                    //  2900:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2902:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2906:      check Inst[23] == 0x1
  OPC_Decode, 130, 14, 152, 1,               //  2910:      decode to MVE_VST42_32 using decoder 152
                                             //  2910:     }
  97, 0,                                     //  2915:     case 0x61: {
  OPC_CheckPredicate, 31,                    //  2917:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2919:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2923:      check Inst[23] == 0x1
  OPC_Decode, 136, 14, 152, 1,               //  2927:      decode to MVE_VST43_32 using decoder 152
                                             //  2927:     }
                                             //  2927:     } // switch Inst[7:0]
                                             //  2927:    }
  1, 0,                                      //  2932:    case 0x1: {
  OPC_SwitchField, 28, 4,                    //  2934:     switch Inst[31:28] {
  14, 11,                                    //  2937:     case 0xe: {
  OPC_CheckPredicate, 31,                    //  2939:      check predicate 31
  OPC_CheckField, 7, 1, 0,                   //  2941:      check Inst[7] == 0x0
  OPC_Decode, 170, 14, 167, 1,               //  2945:      decode to MVE_VSTRWU32 using decoder 167
                                             //  2945:     }
  15, 0,                                     //  2950:     case 0xf: {
  OPC_CheckPredicate, 31,                    //  2952:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  2954:      check Inst[16] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  2958:      check Inst[7] == 0x0
  OPC_Decode, 152, 14, 168, 1,               //  2962:      decode to MVE_VSTRD64_qi using decoder 168
                                             //  2962:     }
                                             //  2962:     } // switch Inst[31:28]
                                             //  2962:    }
                                             //  2962:    } // switch Inst[24]
                                             //  2962:   }
  1, 145, 1,                                 //  2967:   case 0x1: {
  OPC_SwitchField, 24, 1,                    //  2970:    switch Inst[24] {
  0, 105,                                    //  2973:    case 0x0: {
  OPC_SwitchField, 0, 8,                     //  2975:     switch Inst[7:0] {
  0, 15,                                     //  2978:     case 0x0: {
  OPC_CheckPredicate, 31,                    //  2980:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2982:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  2986:      check Inst[23] == 0x1
  OPC_Decode, 193, 9, 156, 1,                //  2990:      decode to MVE_VLD20_32 using decoder 156
                                             //  2990:     }
  1, 15,                                     //  2995:     case 0x1: {
  OPC_CheckPredicate, 31,                    //  2997:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  2999:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  3003:      check Inst[23] == 0x1
  OPC_Decode, 205, 9, 157, 1,                //  3007:      decode to MVE_VLD40_32 using decoder 157
                                             //  3007:     }
  32, 15,                                    //  3012:     case 0x20: {
  OPC_CheckPredicate, 31,                    //  3014:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  3016:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  3020:      check Inst[23] == 0x1
  OPC_Decode, 199, 9, 156, 1,                //  3024:      decode to MVE_VLD21_32 using decoder 156
                                             //  3024:     }
  33, 15,                                    //  3029:     case 0x21: {
  OPC_CheckPredicate, 31,                    //  3031:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  3033:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  3037:      check Inst[23] == 0x1
  OPC_Decode, 211, 9, 157, 1,                //  3041:      decode to MVE_VLD41_32 using decoder 157
                                             //  3041:     }
  65, 15,                                    //  3046:     case 0x41: {
  OPC_CheckPredicate, 31,                    //  3048:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  3050:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  3054:      check Inst[23] == 0x1
  OPC_Decode, 217, 9, 157, 1,                //  3058:      decode to MVE_VLD42_32 using decoder 157
                                             //  3058:     }
  97, 0,                                     //  3063:     case 0x61: {
  OPC_CheckPredicate, 31,                    //  3065:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 //  3067:      check Inst[31:28] == 0xf
  OPC_CheckField, 23, 1, 1,                  //  3071:      check Inst[23] == 0x1
  OPC_Decode, 223, 9, 157, 1,                //  3075:      decode to MVE_VLD43_32 using decoder 157
                                             //  3075:     }
                                             //  3075:     } // switch Inst[7:0]
                                             //  3075:    }
  1, 0,                                      //  3080:    case 0x1: {
  OPC_SwitchField, 28, 4,                    //  3082:     switch Inst[31:28] {
  14, 11,                                    //  3085:     case 0xe: {
  OPC_CheckPredicate, 31,                    //  3087:      check predicate 31
  OPC_CheckField, 7, 1, 0,                   //  3089:      check Inst[7] == 0x0
  OPC_Decode, 138, 10, 167, 1,               //  3093:      decode to MVE_VLDRWU32 using decoder 167
                                             //  3093:     }
  15, 0,                                     //  3098:     case 0xf: {
  OPC_CheckPredicate, 31,                    //  3100:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  3102:      check Inst[16] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  3106:      check Inst[7] == 0x0
  OPC_Decode, 247, 9, 168, 1,                //  3110:      decode to MVE_VLDRDU64_qi using decoder 168
                                             //  3110:     }
                                             //  3110:     } // switch Inst[31:28]
                                             //  3110:    }
                                             //  3110:    } // switch Inst[24]
                                             //  3110:   }
  2, 139, 1,                                 //  3115:   case 0x2: {
  OPC_SwitchField, 24, 1,                    //  3118:    switch Inst[24] {
  0, 99,                                     //  3121:    case 0x0: {
  OPC_SwitchField, 28, 4,                    //  3123:     switch Inst[31:28] {
  14, 11,                                    //  3126:     case 0xe: {
  OPC_CheckPredicate, 31,                    //  3128:      check predicate 31
  OPC_CheckField, 7, 1, 0,                   //  3130:      check Inst[7] == 0x0
  OPC_Decode, 171, 14, 169, 1,               //  3134:      decode to MVE_VSTRWU32_post using decoder 169
                                             //  3134:     }
  15, 0,                                     //  3139:     case 0xf: {
  OPC_SwitchField, 0, 8,                     //  3141:      switch Inst[7:0] {
  0, 11,                                     //  3144:      case 0x0: {
  OPC_CheckPredicate, 31,                    //  3146:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3148:       check Inst[23] == 0x1
  OPC_Decode, 235, 13, 159, 1,               //  3152:       decode to MVE_VST20_32_wb using decoder 159
                                             //  3152:      }
  1, 11,                                     //  3157:      case 0x1: {
  OPC_CheckPredicate, 31,                    //  3159:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3161:       check Inst[23] == 0x1
  OPC_Decode, 247, 13, 160, 1,               //  3165:       decode to MVE_VST40_32_wb using decoder 160
                                             //  3165:      }
  32, 11,                                    //  3170:      case 0x20: {
  OPC_CheckPredicate, 31,                    //  3172:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3174:       check Inst[23] == 0x1
  OPC_Decode, 241, 13, 159, 1,               //  3178:       decode to MVE_VST21_32_wb using decoder 159
                                             //  3178:      }
  33, 11,                                    //  3183:      case 0x21: {
  OPC_CheckPredicate, 31,                    //  3185:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3187:       check Inst[23] == 0x1
  OPC_Decode, 253, 13, 160, 1,               //  3191:       decode to MVE_VST41_32_wb using decoder 160
                                             //  3191:      }
  65, 11,                                    //  3196:      case 0x41: {
  OPC_CheckPredicate, 31,                    //  3198:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3200:       check Inst[23] == 0x1
  OPC_Decode, 131, 14, 160, 1,               //  3204:       decode to MVE_VST42_32_wb using decoder 160
                                             //  3204:      }
  97, 0,                                     //  3209:      case 0x61: {
  OPC_CheckPredicate, 31,                    //  3211:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3213:       check Inst[23] == 0x1
  OPC_Decode, 137, 14, 160, 1,               //  3217:       decode to MVE_VST43_32_wb using decoder 160
                                             //  3217:      }
                                             //  3217:      } // switch Inst[7:0]
                                             //  3217:     }
                                             //  3217:     } // switch Inst[31:28]
                                             //  3217:    }
  1, 0,                                      //  3222:    case 0x1: {
  OPC_SwitchField, 28, 4,                    //  3224:     switch Inst[31:28] {
  14, 11,                                    //  3227:     case 0xe: {
  OPC_CheckPredicate, 31,                    //  3229:      check predicate 31
  OPC_CheckField, 7, 1, 0,                   //  3231:      check Inst[7] == 0x0
  OPC_Decode, 172, 14, 170, 1,               //  3235:      decode to MVE_VSTRWU32_pre using decoder 170
                                             //  3235:     }
  15, 0,                                     //  3240:     case 0xf: {
  OPC_CheckPredicate, 31,                    //  3242:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  3244:      check Inst[16] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  3248:      check Inst[7] == 0x0
  OPC_Decode, 153, 14, 171, 1,               //  3252:      decode to MVE_VSTRD64_qi_pre using decoder 171
                                             //  3252:     }
                                             //  3252:     } // switch Inst[31:28]
                                             //  3252:    }
                                             //  3252:    } // switch Inst[24]
                                             //  3252:   }
  3, 0,                                      //  3257:   case 0x3: {
  OPC_SwitchField, 24, 1,                    //  3259:    switch Inst[24] {
  0, 99,                                     //  3262:    case 0x0: {
  OPC_SwitchField, 28, 4,                    //  3264:     switch Inst[31:28] {
  14, 11,                                    //  3267:     case 0xe: {
  OPC_CheckPredicate, 31,                    //  3269:      check predicate 31
  OPC_CheckField, 7, 1, 0,                   //  3271:      check Inst[7] == 0x0
  OPC_Decode, 139, 10, 169, 1,               //  3275:      decode to MVE_VLDRWU32_post using decoder 169
                                             //  3275:     }
  15, 0,                                     //  3280:     case 0xf: {
  OPC_SwitchField, 0, 8,                     //  3282:      switch Inst[7:0] {
  0, 11,                                     //  3285:      case 0x0: {
  OPC_CheckPredicate, 31,                    //  3287:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3289:       check Inst[23] == 0x1
  OPC_Decode, 194, 9, 165, 1,                //  3293:       decode to MVE_VLD20_32_wb using decoder 165
                                             //  3293:      }
  1, 11,                                     //  3298:      case 0x1: {
  OPC_CheckPredicate, 31,                    //  3300:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3302:       check Inst[23] == 0x1
  OPC_Decode, 206, 9, 166, 1,                //  3306:       decode to MVE_VLD40_32_wb using decoder 166
                                             //  3306:      }
  32, 11,                                    //  3311:      case 0x20: {
  OPC_CheckPredicate, 31,                    //  3313:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3315:       check Inst[23] == 0x1
  OPC_Decode, 200, 9, 165, 1,                //  3319:       decode to MVE_VLD21_32_wb using decoder 165
                                             //  3319:      }
  33, 11,                                    //  3324:      case 0x21: {
  OPC_CheckPredicate, 31,                    //  3326:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3328:       check Inst[23] == 0x1
  OPC_Decode, 212, 9, 166, 1,                //  3332:       decode to MVE_VLD41_32_wb using decoder 166
                                             //  3332:      }
  65, 11,                                    //  3337:      case 0x41: {
  OPC_CheckPredicate, 31,                    //  3339:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3341:       check Inst[23] == 0x1
  OPC_Decode, 218, 9, 166, 1,                //  3345:       decode to MVE_VLD42_32_wb using decoder 166
                                             //  3345:      }
  97, 0,                                     //  3350:      case 0x61: {
  OPC_CheckPredicate, 31,                    //  3352:       check predicate 31
  OPC_CheckField, 23, 1, 1,                  //  3354:       check Inst[23] == 0x1
  OPC_Decode, 224, 9, 166, 1,                //  3358:       decode to MVE_VLD43_32_wb using decoder 166
                                             //  3358:      }
                                             //  3358:      } // switch Inst[7:0]
                                             //  3358:     }
                                             //  3358:     } // switch Inst[31:28]
                                             //  3358:    }
  1, 0,                                      //  3363:    case 0x1: {
  OPC_SwitchField, 28, 4,                    //  3365:     switch Inst[31:28] {
  14, 11,                                    //  3368:     case 0xe: {
  OPC_CheckPredicate, 31,                    //  3370:      check predicate 31
  OPC_CheckField, 7, 1, 0,                   //  3372:      check Inst[7] == 0x0
  OPC_Decode, 140, 10, 170, 1,               //  3376:      decode to MVE_VLDRWU32_pre using decoder 170
                                             //  3376:     }
  15, 0,                                     //  3381:     case 0xf: {
  OPC_CheckPredicate, 31,                    //  3383:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  3385:      check Inst[16] == 0x0
  OPC_CheckField, 7, 1, 0,                   //  3389:      check Inst[7] == 0x0
  OPC_Decode, 248, 9, 171, 1,                //  3393:      decode to MVE_VLDRDU64_qi_pre using decoder 171
                                             //  3393:     }
                                             //  3393:     } // switch Inst[31:28]
                                             //  3393:    }
                                             //  3393:    } // switch Inst[24]
                                             //  3393:   }
                                             //  3393:   } // switch Inst[22:20]
                                             //  3393:  }
                                             //  3393:  } // switch Inst[12:8]
                                             //  3393: }
  7, 0,                                      //  3398: case 0x7: {
  OPC_SwitchField, 23, 2,                    //  3400:  switch Inst[24:23] {
  0, 160, 35,                                //  3403:  case 0x0: {
  OPC_SwitchField, 8, 4,                     //  3406:   switch Inst[11:8] {
  11, 117,                                   //  3409:   case 0xb: {
  OPC_SwitchField, 20, 1,                    //  3411:    switch Inst[20] {
  0, 55,                                     //  3414:    case 0x0: {
  OPC_SwitchField, 22, 1,                    //  3416:     switch Inst[22] {
  0, 33,                                     //  3419:     case 0x0: {
  OPC_SwitchField, 0, 6,                     //  3421:      switch Inst[5:0] {
  16, 15,                                    //  3424:      case 0x10: {
  OPC_CheckPredicate, 34,                    //  3426:       check predicate 34
  OPC_CheckField, 28, 4, 14,                 //  3428:       check Inst[31:28] == 0xe
  OPC_CheckField, 6, 1, 0,                   //  3432:       check Inst[6] == 0x0
  OPC_Decode, 145, 11, 172, 1,               //  3436:       decode to MVE_VMOV_to_lane_32 using decoder 172
                                             //  3436:      }
  48, 0,                                     //  3441:      case 0x30: {
  OPC_CheckPredicate, 32,                    //  3443:       check predicate 32
  OPC_CheckField, 28, 4, 14,                 //  3445:       check Inst[31:28] == 0xe
  OPC_Decode, 144, 11, 173, 1,               //  3449:       decode to MVE_VMOV_to_lane_16 using decoder 173
                                             //  3449:      }
                                             //  3449:      } // switch Inst[5:0]
                                             //  3449:     }
  1, 0,                                      //  3454:     case 0x1: {
  OPC_CheckPredicate, 32,                    //  3456:      check predicate 32
  OPC_CheckField, 28, 4, 14,                 //  3458:      check Inst[31:28] == 0xe
  OPC_CheckField, 0, 5, 16,                  //  3462:      check Inst[4:0] == 0x10
  OPC_Decode, 146, 11, 174, 1,               //  3466:      decode to MVE_VMOV_to_lane_8 using decoder 174
                                             //  3466:     }
                                             //  3466:     } // switch Inst[22]
                                             //  3466:    }
  1, 0,                                      //  3471:    case 0x1: {
  OPC_SwitchField, 22, 1,                    //  3473:     switch Inst[22] {
  0, 33,                                     //  3476:     case 0x0: {
  OPC_SwitchField, 0, 6,                     //  3478:      switch Inst[5:0] {
  16, 15,                                    //  3481:      case 0x10: {
  OPC_CheckPredicate, 34,                    //  3483:       check predicate 34
  OPC_CheckField, 28, 4, 14,                 //  3485:       check Inst[31:28] == 0xe
  OPC_CheckField, 6, 1, 0,                   //  3489:       check Inst[6] == 0x0
  OPC_Decode, 137, 11, 175, 1,               //  3493:       decode to MVE_VMOV_from_lane_32 using decoder 175
                                             //  3493:      }
  48, 0,                                     //  3498:      case 0x30: {
  OPC_CheckPredicate, 32,                    //  3500:       check predicate 32
  OPC_CheckField, 28, 4, 14,                 //  3502:       check Inst[31:28] == 0xe
  OPC_Decode, 138, 11, 176, 1,               //  3506:       decode to MVE_VMOV_from_lane_s16 using decoder 176
                                             //  3506:      }
                                             //  3506:      } // switch Inst[5:0]
                                             //  3506:     }
  1, 0,                                      //  3511:     case 0x1: {
  OPC_CheckPredicate, 32,                    //  3513:      check predicate 32
  OPC_CheckField, 28, 4, 14,                 //  3515:      check Inst[31:28] == 0xe
  OPC_CheckField, 0, 5, 16,                  //  3519:      check Inst[4:0] == 0x10
  OPC_Decode, 139, 11, 177, 1,               //  3523:      decode to MVE_VMOV_from_lane_s8 using decoder 177
                                             //  3523:     }
                                             //  3523:     } // switch Inst[22]
                                             //  3523:    }
                                             //  3523:    } // switch Inst[20]
                                             //  3523:   }
  14, 147, 20,                               //  3528:   case 0xe: {
  OPC_SwitchField, 20, 2,                    //  3531:    switch Inst[21:20] {
  0, 191, 3,                                 //  3534:    case 0x0: {
  OPC_SwitchField, 6, 1,                     //  3537:     switch Inst[6] {
  0, 154, 2,                                 //  3540:     case 0x0: {
  OPC_SwitchField, 0, 1,                     //  3543:      switch Inst[0] {
  0, 137, 1,                                 //  3546:      case 0x0: {
  OPC_SwitchField, 12, 1,                    //  3549:       switch Inst[12] {
  0, 65,                                     //  3552:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  3554:        switch Inst[16] {
  0, 29,                                     //  3557:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  3559:         switch Inst[31:28] {
  14, 11,                                    //  3562:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  3564:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3566:          check Inst[4] == 0x0
  OPC_Decode, 241, 11, 178, 1,               //  3570:          decode to MVE_VQDMLADHs8 using decoder 178
                                             //  3570:         }
  15, 0,                                     //  3575:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  3577:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3579:          check Inst[4] == 0x0
  OPC_Decode, 253, 11, 178, 1,               //  3583:          decode to MVE_VQDMLSDHs8 using decoder 178
                                             //  3583:         }
                                             //  3583:         } // switch Inst[31:28]
                                             //  3583:        }
  1, 0,                                      //  3588:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  3590:         switch Inst[31:28] {
  14, 11,                                    //  3593:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  3595:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3597:          check Inst[4] == 0x0
  OPC_Decode, 162, 11, 179, 1,               //  3601:          decode to MVE_VMULLBs8 using decoder 179
                                             //  3601:         }
  15, 0,                                     //  3606:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  3608:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3610:          check Inst[4] == 0x0
  OPC_Decode, 165, 11, 179, 1,               //  3614:          decode to MVE_VMULLBu8 using decoder 179
                                             //  3614:         }
                                             //  3614:         } // switch Inst[31:28]
                                             //  3614:        }
                                             //  3614:        } // switch Inst[16]
                                             //  3614:       }
  1, 0,                                      //  3619:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  3621:        switch Inst[16] {
  0, 29,                                     //  3624:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  3626:         switch Inst[31:28] {
  14, 11,                                    //  3629:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  3631:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3633:          check Inst[4] == 0x0
  OPC_Decode, 238, 11, 178, 1,               //  3637:          decode to MVE_VQDMLADHXs8 using decoder 178
                                             //  3637:         }
  15, 0,                                     //  3642:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  3644:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3646:          check Inst[4] == 0x0
  OPC_Decode, 250, 11, 178, 1,               //  3650:          decode to MVE_VQDMLSDHXs8 using decoder 178
                                             //  3650:         }
                                             //  3650:         } // switch Inst[31:28]
                                             //  3650:        }
  1, 0,                                      //  3655:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  3657:         switch Inst[31:28] {
  14, 11,                                    //  3660:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  3662:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3664:          check Inst[4] == 0x0
  OPC_Decode, 170, 11, 179, 1,               //  3668:          decode to MVE_VMULLTs8 using decoder 179
                                             //  3668:         }
  15, 0,                                     //  3673:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  3675:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3677:          check Inst[4] == 0x0
  OPC_Decode, 173, 11, 179, 1,               //  3681:          decode to MVE_VMULLTu8 using decoder 179
                                             //  3681:         }
                                             //  3681:         } // switch Inst[31:28]
                                             //  3681:        }
                                             //  3681:        } // switch Inst[16]
                                             //  3681:       }
                                             //  3681:       } // switch Inst[12]
                                             //  3681:      }
  1, 0,                                      //  3686:      case 0x1: {
  OPC_SwitchField, 12, 1,                    //  3688:       switch Inst[12] {
  0, 65,                                     //  3691:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  3693:        switch Inst[16] {
  0, 29,                                     //  3696:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  3698:         switch Inst[31:28] {
  14, 11,                                    //  3701:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  3703:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3705:          check Inst[4] == 0x0
  OPC_Decode, 160, 12, 178, 1,               //  3709:          decode to MVE_VQRDMLADHs8 using decoder 178
                                             //  3709:         }
  15, 0,                                     //  3714:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  3716:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3718:          check Inst[4] == 0x0
  OPC_Decode, 172, 12, 178, 1,               //  3722:          decode to MVE_VQRDMLSDHs8 using decoder 178
                                             //  3722:         }
                                             //  3722:         } // switch Inst[31:28]
                                             //  3722:        }
  1, 0,                                      //  3727:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  3729:         switch Inst[31:28] {
  14, 11,                                    //  3732:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  3734:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3736:          check Inst[4] == 0x0
  OPC_Decode, 154, 11, 179, 1,               //  3740:          decode to MVE_VMULHs8 using decoder 179
                                             //  3740:         }
  15, 0,                                     //  3745:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  3747:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3749:          check Inst[4] == 0x0
  OPC_Decode, 157, 11, 179, 1,               //  3753:          decode to MVE_VMULHu8 using decoder 179
                                             //  3753:         }
                                             //  3753:         } // switch Inst[31:28]
                                             //  3753:        }
                                             //  3753:        } // switch Inst[16]
                                             //  3753:       }
  1, 0,                                      //  3758:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  3760:        switch Inst[16] {
  0, 29,                                     //  3763:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  3765:         switch Inst[31:28] {
  14, 11,                                    //  3768:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  3770:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3772:          check Inst[4] == 0x0
  OPC_Decode, 157, 12, 178, 1,               //  3776:          decode to MVE_VQRDMLADHXs8 using decoder 178
                                             //  3776:         }
  15, 0,                                     //  3781:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  3783:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3785:          check Inst[4] == 0x0
  OPC_Decode, 169, 12, 178, 1,               //  3789:          decode to MVE_VQRDMLSDHXs8 using decoder 178
                                             //  3789:         }
                                             //  3789:         } // switch Inst[31:28]
                                             //  3789:        }
  1, 0,                                      //  3794:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  3796:         switch Inst[31:28] {
  14, 11,                                    //  3799:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  3801:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3803:          check Inst[4] == 0x0
  OPC_Decode, 156, 13, 179, 1,               //  3807:          decode to MVE_VRMULHs8 using decoder 179
                                             //  3807:         }
  15, 0,                                     //  3812:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  3814:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  3816:          check Inst[4] == 0x0
  OPC_Decode, 159, 13, 179, 1,               //  3820:          decode to MVE_VRMULHu8 using decoder 179
                                             //  3820:         }
                                             //  3820:         } // switch Inst[31:28]
                                             //  3820:        }
                                             //  3820:        } // switch Inst[16]
                                             //  3820:       }
                                             //  3820:       } // switch Inst[12]
                                             //  3820:      }
                                             //  3820:      } // switch Inst[0]
                                             //  3820:     }
  1, 0,                                      //  3825:     case 0x1: {
  OPC_SwitchField, 4, 2,                     //  3827:      switch Inst[5:4] {
  0, 65,                                     //  3830:      case 0x0: {
  OPC_SwitchField, 12, 1,                    //  3832:       switch Inst[12] {
  0, 29,                                     //  3835:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  3837:        switch Inst[16] {
  0, 11,                                     //  3840:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  3842:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  3844:         check Inst[31:28] == 0xe
  OPC_Decode, 163, 12, 180, 1,               //  3848:         decode to MVE_VQRDMLAH_qrs8 using decoder 180
                                             //  3848:        }
  1, 0,                                      //  3853:        case 0x1: {
  OPC_CheckPredicate, 31,                    //  3855:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  3857:         check Inst[31:28] == 0xe
  OPC_Decode, 232, 10, 180, 1,               //  3861:         decode to MVE_VMLA_qr_i8 using decoder 180
                                             //  3861:        }
                                             //  3861:        } // switch Inst[16]
                                             //  3861:       }
  1, 0,                                      //  3866:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  3868:        switch Inst[16] {
  0, 11,                                     //  3871:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  3873:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  3875:         check Inst[31:28] == 0xe
  OPC_Decode, 166, 12, 180, 1,               //  3879:         decode to MVE_VQRDMLASH_qrs8 using decoder 180
                                             //  3879:        }
  1, 0,                                      //  3884:        case 0x1: {
  OPC_CheckPredicate, 31,                    //  3886:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  3888:         check Inst[31:28] == 0xe
  OPC_Decode, 229, 10, 180, 1,               //  3892:         decode to MVE_VMLAS_qr_i8 using decoder 180
                                             //  3892:        }
                                             //  3892:        } // switch Inst[16]
                                             //  3892:       }
                                             //  3892:       } // switch Inst[12]
                                             //  3892:      }
  2, 0,                                      //  3897:      case 0x2: {
  OPC_SwitchField, 12, 1,                    //  3899:       switch Inst[12] {
  0, 39,                                     //  3902:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  3904:        switch Inst[16] {
  0, 11,                                     //  3907:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  3909:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  3911:         check Inst[31:28] == 0xe
  OPC_Decode, 244, 11, 180, 1,               //  3915:         decode to MVE_VQDMLAH_qrs8 using decoder 180
                                             //  3915:        }
  1, 0,                                      //  3920:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  3922:         switch Inst[31:28] {
  14, 7,                                     //  3925:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  3927:          check predicate 31
  OPC_Decode, 128, 12, 181, 1,               //  3929:          decode to MVE_VQDMULH_qr_s8 using decoder 181
                                             //  3929:         }
  15, 0,                                     //  3934:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  3936:          check predicate 31
  OPC_Decode, 175, 12, 181, 1,               //  3938:          decode to MVE_VQRDMULH_qr_s8 using decoder 181
                                             //  3938:         }
                                             //  3938:         } // switch Inst[31:28]
                                             //  3938:        }
                                             //  3938:        } // switch Inst[16]
                                             //  3938:       }
  1, 0,                                      //  3943:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  3945:        switch Inst[16] {
  0, 11,                                     //  3948:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  3950:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  3952:         check Inst[31:28] == 0xe
  OPC_Decode, 247, 11, 180, 1,               //  3956:         decode to MVE_VQDMLASH_qrs8 using decoder 180
                                             //  3956:        }
  1, 0,                                      //  3961:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  3963:         switch Inst[31:28] {
  14, 7,                                     //  3966:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  3968:          check predicate 31
  OPC_Decode, 178, 11, 181, 1,               //  3970:          decode to MVE_VMUL_qr_i8 using decoder 181
                                             //  3970:         }
  15, 0,                                     //  3975:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  3977:          check predicate 31
  OPC_Decode, 190, 8, 181, 1,                //  3979:          decode to MVE_VBRSR8 using decoder 181
                                             //  3979:         }
                                             //  3979:         } // switch Inst[31:28]
                                             //  3979:        }
                                             //  3979:        } // switch Inst[16]
                                             //  3979:       }
                                             //  3979:       } // switch Inst[12]
                                             //  3979:      }
                                             //  3979:      } // switch Inst[5:4]
                                             //  3979:     }
                                             //  3979:     } // switch Inst[6]
                                             //  3979:    }
  1, 191, 3,                                 //  3984:    case 0x1: {
  OPC_SwitchField, 6, 1,                     //  3987:     switch Inst[6] {
  0, 154, 2,                                 //  3990:     case 0x0: {
  OPC_SwitchField, 0, 1,                     //  3993:      switch Inst[0] {
  0, 137, 1,                                 //  3996:      case 0x0: {
  OPC_SwitchField, 12, 1,                    //  3999:       switch Inst[12] {
  0, 65,                                     //  4002:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  4004:        switch Inst[16] {
  0, 29,                                     //  4007:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  4009:         switch Inst[31:28] {
  14, 11,                                    //  4012:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4014:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4016:          check Inst[4] == 0x0
  OPC_Decode, 239, 11, 178, 1,               //  4020:          decode to MVE_VQDMLADHs16 using decoder 178
                                             //  4020:         }
  15, 0,                                     //  4025:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4027:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4029:          check Inst[4] == 0x0
  OPC_Decode, 251, 11, 178, 1,               //  4033:          decode to MVE_VQDMLSDHs16 using decoder 178
                                             //  4033:         }
                                             //  4033:         } // switch Inst[31:28]
                                             //  4033:        }
  1, 0,                                      //  4038:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4040:         switch Inst[31:28] {
  14, 11,                                    //  4043:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4045:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4047:          check Inst[4] == 0x0
  OPC_Decode, 160, 11, 179, 1,               //  4051:          decode to MVE_VMULLBs16 using decoder 179
                                             //  4051:         }
  15, 0,                                     //  4056:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4058:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4060:          check Inst[4] == 0x0
  OPC_Decode, 163, 11, 179, 1,               //  4064:          decode to MVE_VMULLBu16 using decoder 179
                                             //  4064:         }
                                             //  4064:         } // switch Inst[31:28]
                                             //  4064:        }
                                             //  4064:        } // switch Inst[16]
                                             //  4064:       }
  1, 0,                                      //  4069:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  4071:        switch Inst[16] {
  0, 29,                                     //  4074:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  4076:         switch Inst[31:28] {
  14, 11,                                    //  4079:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4081:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4083:          check Inst[4] == 0x0
  OPC_Decode, 236, 11, 178, 1,               //  4087:          decode to MVE_VQDMLADHXs16 using decoder 178
                                             //  4087:         }
  15, 0,                                     //  4092:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4094:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4096:          check Inst[4] == 0x0
  OPC_Decode, 248, 11, 178, 1,               //  4100:          decode to MVE_VQDMLSDHXs16 using decoder 178
                                             //  4100:         }
                                             //  4100:         } // switch Inst[31:28]
                                             //  4100:        }
  1, 0,                                      //  4105:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4107:         switch Inst[31:28] {
  14, 11,                                    //  4110:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4112:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4114:          check Inst[4] == 0x0
  OPC_Decode, 168, 11, 179, 1,               //  4118:          decode to MVE_VMULLTs16 using decoder 179
                                             //  4118:         }
  15, 0,                                     //  4123:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4125:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4127:          check Inst[4] == 0x0
  OPC_Decode, 171, 11, 179, 1,               //  4131:          decode to MVE_VMULLTu16 using decoder 179
                                             //  4131:         }
                                             //  4131:         } // switch Inst[31:28]
                                             //  4131:        }
                                             //  4131:        } // switch Inst[16]
                                             //  4131:       }
                                             //  4131:       } // switch Inst[12]
                                             //  4131:      }
  1, 0,                                      //  4136:      case 0x1: {
  OPC_SwitchField, 12, 1,                    //  4138:       switch Inst[12] {
  0, 65,                                     //  4141:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  4143:        switch Inst[16] {
  0, 29,                                     //  4146:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  4148:         switch Inst[31:28] {
  14, 11,                                    //  4151:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4153:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4155:          check Inst[4] == 0x0
  OPC_Decode, 158, 12, 178, 1,               //  4159:          decode to MVE_VQRDMLADHs16 using decoder 178
                                             //  4159:         }
  15, 0,                                     //  4164:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4166:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4168:          check Inst[4] == 0x0
  OPC_Decode, 170, 12, 178, 1,               //  4172:          decode to MVE_VQRDMLSDHs16 using decoder 178
                                             //  4172:         }
                                             //  4172:         } // switch Inst[31:28]
                                             //  4172:        }
  1, 0,                                      //  4177:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4179:         switch Inst[31:28] {
  14, 11,                                    //  4182:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4184:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4186:          check Inst[4] == 0x0
  OPC_Decode, 152, 11, 179, 1,               //  4190:          decode to MVE_VMULHs16 using decoder 179
                                             //  4190:         }
  15, 0,                                     //  4195:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4197:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4199:          check Inst[4] == 0x0
  OPC_Decode, 155, 11, 179, 1,               //  4203:          decode to MVE_VMULHu16 using decoder 179
                                             //  4203:         }
                                             //  4203:         } // switch Inst[31:28]
                                             //  4203:        }
                                             //  4203:        } // switch Inst[16]
                                             //  4203:       }
  1, 0,                                      //  4208:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  4210:        switch Inst[16] {
  0, 29,                                     //  4213:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  4215:         switch Inst[31:28] {
  14, 11,                                    //  4218:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4220:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4222:          check Inst[4] == 0x0
  OPC_Decode, 155, 12, 178, 1,               //  4226:          decode to MVE_VQRDMLADHXs16 using decoder 178
                                             //  4226:         }
  15, 0,                                     //  4231:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4233:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4235:          check Inst[4] == 0x0
  OPC_Decode, 167, 12, 178, 1,               //  4239:          decode to MVE_VQRDMLSDHXs16 using decoder 178
                                             //  4239:         }
                                             //  4239:         } // switch Inst[31:28]
                                             //  4239:        }
  1, 0,                                      //  4244:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4246:         switch Inst[31:28] {
  14, 11,                                    //  4249:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4251:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4253:          check Inst[4] == 0x0
  OPC_Decode, 154, 13, 179, 1,               //  4257:          decode to MVE_VRMULHs16 using decoder 179
                                             //  4257:         }
  15, 0,                                     //  4262:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4264:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4266:          check Inst[4] == 0x0
  OPC_Decode, 157, 13, 179, 1,               //  4270:          decode to MVE_VRMULHu16 using decoder 179
                                             //  4270:         }
                                             //  4270:         } // switch Inst[31:28]
                                             //  4270:        }
                                             //  4270:        } // switch Inst[16]
                                             //  4270:       }
                                             //  4270:       } // switch Inst[12]
                                             //  4270:      }
                                             //  4270:      } // switch Inst[0]
                                             //  4270:     }
  1, 0,                                      //  4275:     case 0x1: {
  OPC_SwitchField, 4, 2,                     //  4277:      switch Inst[5:4] {
  0, 65,                                     //  4280:      case 0x0: {
  OPC_SwitchField, 12, 1,                    //  4282:       switch Inst[12] {
  0, 29,                                     //  4285:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  4287:        switch Inst[16] {
  0, 11,                                     //  4290:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  4292:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4294:         check Inst[31:28] == 0xe
  OPC_Decode, 161, 12, 180, 1,               //  4298:         decode to MVE_VQRDMLAH_qrs16 using decoder 180
                                             //  4298:        }
  1, 0,                                      //  4303:        case 0x1: {
  OPC_CheckPredicate, 31,                    //  4305:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4307:         check Inst[31:28] == 0xe
  OPC_Decode, 230, 10, 180, 1,               //  4311:         decode to MVE_VMLA_qr_i16 using decoder 180
                                             //  4311:        }
                                             //  4311:        } // switch Inst[16]
                                             //  4311:       }
  1, 0,                                      //  4316:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  4318:        switch Inst[16] {
  0, 11,                                     //  4321:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  4323:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4325:         check Inst[31:28] == 0xe
  OPC_Decode, 164, 12, 180, 1,               //  4329:         decode to MVE_VQRDMLASH_qrs16 using decoder 180
                                             //  4329:        }
  1, 0,                                      //  4334:        case 0x1: {
  OPC_CheckPredicate, 31,                    //  4336:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4338:         check Inst[31:28] == 0xe
  OPC_Decode, 227, 10, 180, 1,               //  4342:         decode to MVE_VMLAS_qr_i16 using decoder 180
                                             //  4342:        }
                                             //  4342:        } // switch Inst[16]
                                             //  4342:       }
                                             //  4342:       } // switch Inst[12]
                                             //  4342:      }
  2, 0,                                      //  4347:      case 0x2: {
  OPC_SwitchField, 12, 1,                    //  4349:       switch Inst[12] {
  0, 39,                                     //  4352:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  4354:        switch Inst[16] {
  0, 11,                                     //  4357:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  4359:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4361:         check Inst[31:28] == 0xe
  OPC_Decode, 242, 11, 180, 1,               //  4365:         decode to MVE_VQDMLAH_qrs16 using decoder 180
                                             //  4365:        }
  1, 0,                                      //  4370:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4372:         switch Inst[31:28] {
  14, 7,                                     //  4375:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4377:          check predicate 31
  OPC_Decode, 254, 11, 181, 1,               //  4379:          decode to MVE_VQDMULH_qr_s16 using decoder 181
                                             //  4379:         }
  15, 0,                                     //  4384:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4386:          check predicate 31
  OPC_Decode, 173, 12, 181, 1,               //  4388:          decode to MVE_VQRDMULH_qr_s16 using decoder 181
                                             //  4388:         }
                                             //  4388:         } // switch Inst[31:28]
                                             //  4388:        }
                                             //  4388:        } // switch Inst[16]
                                             //  4388:       }
  1, 0,                                      //  4393:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  4395:        switch Inst[16] {
  0, 11,                                     //  4398:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  4400:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4402:         check Inst[31:28] == 0xe
  OPC_Decode, 245, 11, 180, 1,               //  4406:         decode to MVE_VQDMLASH_qrs16 using decoder 180
                                             //  4406:        }
  1, 0,                                      //  4411:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4413:         switch Inst[31:28] {
  14, 7,                                     //  4416:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4418:          check predicate 31
  OPC_Decode, 176, 11, 181, 1,               //  4420:          decode to MVE_VMUL_qr_i16 using decoder 181
                                             //  4420:         }
  15, 0,                                     //  4425:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4427:          check predicate 31
  OPC_Decode, 188, 8, 181, 1,                //  4429:          decode to MVE_VBRSR16 using decoder 181
                                             //  4429:         }
                                             //  4429:         } // switch Inst[31:28]
                                             //  4429:        }
                                             //  4429:        } // switch Inst[16]
                                             //  4429:       }
                                             //  4429:       } // switch Inst[12]
                                             //  4429:      }
                                             //  4429:      } // switch Inst[5:4]
                                             //  4429:     }
                                             //  4429:     } // switch Inst[6]
                                             //  4429:    }
  2, 191, 3,                                 //  4434:    case 0x2: {
  OPC_SwitchField, 6, 1,                     //  4437:     switch Inst[6] {
  0, 154, 2,                                 //  4440:     case 0x0: {
  OPC_SwitchField, 0, 1,                     //  4443:      switch Inst[0] {
  0, 137, 1,                                 //  4446:      case 0x0: {
  OPC_SwitchField, 12, 1,                    //  4449:       switch Inst[12] {
  0, 65,                                     //  4452:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  4454:        switch Inst[16] {
  0, 29,                                     //  4457:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  4459:         switch Inst[31:28] {
  14, 11,                                    //  4462:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4464:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4466:          check Inst[4] == 0x0
  OPC_Decode, 240, 11, 178, 1,               //  4470:          decode to MVE_VQDMLADHs32 using decoder 178
                                             //  4470:         }
  15, 0,                                     //  4475:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4477:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4479:          check Inst[4] == 0x0
  OPC_Decode, 252, 11, 178, 1,               //  4483:          decode to MVE_VQDMLSDHs32 using decoder 178
                                             //  4483:         }
                                             //  4483:         } // switch Inst[31:28]
                                             //  4483:        }
  1, 0,                                      //  4488:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4490:         switch Inst[31:28] {
  14, 11,                                    //  4493:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4495:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4497:          check Inst[4] == 0x0
  OPC_Decode, 161, 11, 179, 1,               //  4501:          decode to MVE_VMULLBs32 using decoder 179
                                             //  4501:         }
  15, 0,                                     //  4506:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4508:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4510:          check Inst[4] == 0x0
  OPC_Decode, 164, 11, 179, 1,               //  4514:          decode to MVE_VMULLBu32 using decoder 179
                                             //  4514:         }
                                             //  4514:         } // switch Inst[31:28]
                                             //  4514:        }
                                             //  4514:        } // switch Inst[16]
                                             //  4514:       }
  1, 0,                                      //  4519:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  4521:        switch Inst[16] {
  0, 29,                                     //  4524:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  4526:         switch Inst[31:28] {
  14, 11,                                    //  4529:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4531:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4533:          check Inst[4] == 0x0
  OPC_Decode, 237, 11, 178, 1,               //  4537:          decode to MVE_VQDMLADHXs32 using decoder 178
                                             //  4537:         }
  15, 0,                                     //  4542:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4544:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4546:          check Inst[4] == 0x0
  OPC_Decode, 249, 11, 178, 1,               //  4550:          decode to MVE_VQDMLSDHXs32 using decoder 178
                                             //  4550:         }
                                             //  4550:         } // switch Inst[31:28]
                                             //  4550:        }
  1, 0,                                      //  4555:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4557:         switch Inst[31:28] {
  14, 11,                                    //  4560:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4562:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4564:          check Inst[4] == 0x0
  OPC_Decode, 169, 11, 179, 1,               //  4568:          decode to MVE_VMULLTs32 using decoder 179
                                             //  4568:         }
  15, 0,                                     //  4573:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4575:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4577:          check Inst[4] == 0x0
  OPC_Decode, 172, 11, 179, 1,               //  4581:          decode to MVE_VMULLTu32 using decoder 179
                                             //  4581:         }
                                             //  4581:         } // switch Inst[31:28]
                                             //  4581:        }
                                             //  4581:        } // switch Inst[16]
                                             //  4581:       }
                                             //  4581:       } // switch Inst[12]
                                             //  4581:      }
  1, 0,                                      //  4586:      case 0x1: {
  OPC_SwitchField, 12, 1,                    //  4588:       switch Inst[12] {
  0, 65,                                     //  4591:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  4593:        switch Inst[16] {
  0, 29,                                     //  4596:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  4598:         switch Inst[31:28] {
  14, 11,                                    //  4601:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4603:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4605:          check Inst[4] == 0x0
  OPC_Decode, 159, 12, 178, 1,               //  4609:          decode to MVE_VQRDMLADHs32 using decoder 178
                                             //  4609:         }
  15, 0,                                     //  4614:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4616:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4618:          check Inst[4] == 0x0
  OPC_Decode, 171, 12, 178, 1,               //  4622:          decode to MVE_VQRDMLSDHs32 using decoder 178
                                             //  4622:         }
                                             //  4622:         } // switch Inst[31:28]
                                             //  4622:        }
  1, 0,                                      //  4627:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4629:         switch Inst[31:28] {
  14, 11,                                    //  4632:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4634:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4636:          check Inst[4] == 0x0
  OPC_Decode, 153, 11, 179, 1,               //  4640:          decode to MVE_VMULHs32 using decoder 179
                                             //  4640:         }
  15, 0,                                     //  4645:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4647:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4649:          check Inst[4] == 0x0
  OPC_Decode, 156, 11, 179, 1,               //  4653:          decode to MVE_VMULHu32 using decoder 179
                                             //  4653:         }
                                             //  4653:         } // switch Inst[31:28]
                                             //  4653:        }
                                             //  4653:        } // switch Inst[16]
                                             //  4653:       }
  1, 0,                                      //  4658:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  4660:        switch Inst[16] {
  0, 29,                                     //  4663:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  4665:         switch Inst[31:28] {
  14, 11,                                    //  4668:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4670:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4672:          check Inst[4] == 0x0
  OPC_Decode, 156, 12, 178, 1,               //  4676:          decode to MVE_VQRDMLADHXs32 using decoder 178
                                             //  4676:         }
  15, 0,                                     //  4681:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4683:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4685:          check Inst[4] == 0x0
  OPC_Decode, 168, 12, 178, 1,               //  4689:          decode to MVE_VQRDMLSDHXs32 using decoder 178
                                             //  4689:         }
                                             //  4689:         } // switch Inst[31:28]
                                             //  4689:        }
  1, 0,                                      //  4694:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4696:         switch Inst[31:28] {
  14, 11,                                    //  4699:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4701:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4703:          check Inst[4] == 0x0
  OPC_Decode, 155, 13, 179, 1,               //  4707:          decode to MVE_VRMULHs32 using decoder 179
                                             //  4707:         }
  15, 0,                                     //  4712:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4714:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4716:          check Inst[4] == 0x0
  OPC_Decode, 158, 13, 179, 1,               //  4720:          decode to MVE_VRMULHu32 using decoder 179
                                             //  4720:         }
                                             //  4720:         } // switch Inst[31:28]
                                             //  4720:        }
                                             //  4720:        } // switch Inst[16]
                                             //  4720:       }
                                             //  4720:       } // switch Inst[12]
                                             //  4720:      }
                                             //  4720:      } // switch Inst[0]
                                             //  4720:     }
  1, 0,                                      //  4725:     case 0x1: {
  OPC_SwitchField, 4, 2,                     //  4727:      switch Inst[5:4] {
  0, 65,                                     //  4730:      case 0x0: {
  OPC_SwitchField, 12, 1,                    //  4732:       switch Inst[12] {
  0, 29,                                     //  4735:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  4737:        switch Inst[16] {
  0, 11,                                     //  4740:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  4742:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4744:         check Inst[31:28] == 0xe
  OPC_Decode, 162, 12, 180, 1,               //  4748:         decode to MVE_VQRDMLAH_qrs32 using decoder 180
                                             //  4748:        }
  1, 0,                                      //  4753:        case 0x1: {
  OPC_CheckPredicate, 31,                    //  4755:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4757:         check Inst[31:28] == 0xe
  OPC_Decode, 231, 10, 180, 1,               //  4761:         decode to MVE_VMLA_qr_i32 using decoder 180
                                             //  4761:        }
                                             //  4761:        } // switch Inst[16]
                                             //  4761:       }
  1, 0,                                      //  4766:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  4768:        switch Inst[16] {
  0, 11,                                     //  4771:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  4773:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4775:         check Inst[31:28] == 0xe
  OPC_Decode, 165, 12, 180, 1,               //  4779:         decode to MVE_VQRDMLASH_qrs32 using decoder 180
                                             //  4779:        }
  1, 0,                                      //  4784:        case 0x1: {
  OPC_CheckPredicate, 31,                    //  4786:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4788:         check Inst[31:28] == 0xe
  OPC_Decode, 228, 10, 180, 1,               //  4792:         decode to MVE_VMLAS_qr_i32 using decoder 180
                                             //  4792:        }
                                             //  4792:        } // switch Inst[16]
                                             //  4792:       }
                                             //  4792:       } // switch Inst[12]
                                             //  4792:      }
  2, 0,                                      //  4797:      case 0x2: {
  OPC_SwitchField, 12, 1,                    //  4799:       switch Inst[12] {
  0, 39,                                     //  4802:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  4804:        switch Inst[16] {
  0, 11,                                     //  4807:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  4809:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4811:         check Inst[31:28] == 0xe
  OPC_Decode, 243, 11, 180, 1,               //  4815:         decode to MVE_VQDMLAH_qrs32 using decoder 180
                                             //  4815:        }
  1, 0,                                      //  4820:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4822:         switch Inst[31:28] {
  14, 7,                                     //  4825:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4827:          check predicate 31
  OPC_Decode, 255, 11, 181, 1,               //  4829:          decode to MVE_VQDMULH_qr_s32 using decoder 181
                                             //  4829:         }
  15, 0,                                     //  4834:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4836:          check predicate 31
  OPC_Decode, 174, 12, 181, 1,               //  4838:          decode to MVE_VQRDMULH_qr_s32 using decoder 181
                                             //  4838:         }
                                             //  4838:         } // switch Inst[31:28]
                                             //  4838:        }
                                             //  4838:        } // switch Inst[16]
                                             //  4838:       }
  1, 0,                                      //  4843:       case 0x1: {
  OPC_SwitchField, 16, 1,                    //  4845:        switch Inst[16] {
  0, 11,                                     //  4848:        case 0x0: {
  OPC_CheckPredicate, 31,                    //  4850:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  4852:         check Inst[31:28] == 0xe
  OPC_Decode, 246, 11, 180, 1,               //  4856:         decode to MVE_VQDMLASH_qrs32 using decoder 180
                                             //  4856:        }
  1, 0,                                      //  4861:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4863:         switch Inst[31:28] {
  14, 7,                                     //  4866:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4868:          check predicate 31
  OPC_Decode, 177, 11, 181, 1,               //  4870:          decode to MVE_VMUL_qr_i32 using decoder 181
                                             //  4870:         }
  15, 0,                                     //  4875:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4877:          check predicate 31
  OPC_Decode, 189, 8, 181, 1,                //  4879:          decode to MVE_VBRSR32 using decoder 181
                                             //  4879:         }
                                             //  4879:         } // switch Inst[31:28]
                                             //  4879:        }
                                             //  4879:        } // switch Inst[16]
                                             //  4879:       }
                                             //  4879:       } // switch Inst[12]
                                             //  4879:      }
                                             //  4879:      } // switch Inst[5:4]
                                             //  4879:     }
                                             //  4879:     } // switch Inst[6]
                                             //  4879:    }
  3, 0,                                      //  4884:    case 0x3: {
  OPC_SwitchField, 6, 1,                     //  4886:     switch Inst[6] {
  0, 159, 6,                                 //  4889:     case 0x0: {
  OPC_SwitchField, 16, 1,                    //  4892:      switch Inst[16] {
  0, 29,                                     //  4895:      case 0x0: {
  OPC_SwitchField, 28, 4,                    //  4897:       switch Inst[31:28] {
  14, 11,                                    //  4900:       case 0xe: {
  OPC_CheckPredicate, 33,                    //  4902:        check predicate 33
  OPC_CheckField, 4, 1, 0,                   //  4904:        check Inst[4] == 0x0
  OPC_Decode, 226, 8, 182, 1,                //  4908:        decode to MVE_VCMULf16 using decoder 182
                                             //  4908:       }
  15, 0,                                     //  4913:       case 0xf: {
  OPC_CheckPredicate, 33,                    //  4915:        check predicate 33
  OPC_CheckField, 4, 1, 0,                   //  4917:        check Inst[4] == 0x0
  OPC_Decode, 227, 8, 182, 1,                //  4921:        decode to MVE_VCMULf32 using decoder 182
                                             //  4921:       }
                                             //  4921:       } // switch Inst[31:28]
                                             //  4921:      }
  1, 0,                                      //  4926:      case 0x1: {
  OPC_SwitchField, 0, 1,                     //  4928:       switch Inst[0] {
  0, 65,                                     //  4931:       case 0x0: {
  OPC_SwitchField, 12, 1,                    //  4933:        switch Inst[12] {
  0, 29,                                     //  4936:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  4938:         switch Inst[31:28] {
  14, 11,                                    //  4941:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4943:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4945:          check Inst[4] == 0x0
  OPC_Decode, 159, 11, 179, 1,               //  4949:          decode to MVE_VMULLBp8 using decoder 179
                                             //  4949:         }
  15, 0,                                     //  4954:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4956:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4958:          check Inst[4] == 0x0
  OPC_Decode, 158, 11, 179, 1,               //  4962:          decode to MVE_VMULLBp16 using decoder 179
                                             //  4962:         }
                                             //  4962:         } // switch Inst[31:28]
                                             //  4962:        }
  1, 0,                                      //  4967:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  4969:         switch Inst[31:28] {
  14, 11,                                    //  4972:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  4974:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4976:          check Inst[4] == 0x0
  OPC_Decode, 167, 11, 179, 1,               //  4980:          decode to MVE_VMULLTp8 using decoder 179
                                             //  4980:         }
  15, 0,                                     //  4985:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  4987:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  4989:          check Inst[4] == 0x0
  OPC_Decode, 166, 11, 179, 1,               //  4993:          decode to MVE_VMULLTp16 using decoder 179
                                             //  4993:         }
                                             //  4993:         } // switch Inst[31:28]
                                             //  4993:        }
                                             //  4993:        } // switch Inst[12]
                                             //  4993:       }
  1, 0,                                      //  4998:       case 0x1: {
  OPC_SwitchField, 17, 3,                    //  5000:        switch Inst[19:17] {
  0, 137, 1,                                 //  5003:        case 0x0: {
  OPC_SwitchField, 7, 1,                     //  5006:         switch Inst[7] {
  0, 65,                                     //  5009:         case 0x0: {
  OPC_SwitchField, 12, 1,                    //  5011:          switch Inst[12] {
  0, 29,                                     //  5014:          case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5016:           switch Inst[31:28] {
  14, 11,                                    //  5019:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5021:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5023:            check Inst[4] == 0x0
  OPC_Decode, 195, 13, 183, 1,               //  5027:            decode to MVE_VSHLL_lws8bh using decoder 183
                                             //  5027:           }
  15, 0,                                     //  5032:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5034:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5036:            check Inst[4] == 0x0
  OPC_Decode, 199, 13, 183, 1,               //  5040:            decode to MVE_VSHLL_lwu8bh using decoder 183
                                             //  5040:           }
                                             //  5040:           } // switch Inst[31:28]
                                             //  5040:          }
  1, 0,                                      //  5045:          case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5047:           switch Inst[31:28] {
  14, 11,                                    //  5050:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5052:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5054:            check Inst[4] == 0x0
  OPC_Decode, 196, 13, 183, 1,               //  5058:            decode to MVE_VSHLL_lws8th using decoder 183
                                             //  5058:           }
  15, 0,                                     //  5063:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5065:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5067:            check Inst[4] == 0x0
  OPC_Decode, 200, 13, 183, 1,               //  5071:            decode to MVE_VSHLL_lwu8th using decoder 183
                                             //  5071:           }
                                             //  5071:           } // switch Inst[31:28]
                                             //  5071:          }
                                             //  5071:          } // switch Inst[12]
                                             //  5071:         }
  1, 0,                                      //  5076:         case 0x1: {
  OPC_SwitchField, 12, 1,                    //  5078:          switch Inst[12] {
  0, 29,                                     //  5081:          case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5083:           switch Inst[31:28] {
  14, 11,                                    //  5086:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5088:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5090:            check Inst[4] == 0x0
  OPC_Decode, 148, 12, 184, 1,               //  5094:            decode to MVE_VQMOVUNs16bh using decoder 184
                                             //  5094:           }
  15, 0,                                     //  5099:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5101:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5103:            check Inst[4] == 0x0
  OPC_Decode, 133, 11, 184, 1,               //  5107:            decode to MVE_VMOVNi16bh using decoder 184
                                             //  5107:           }
                                             //  5107:           } // switch Inst[31:28]
                                             //  5107:          }
  1, 0,                                      //  5112:          case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5114:           switch Inst[31:28] {
  14, 11,                                    //  5117:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5119:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5121:            check Inst[4] == 0x0
  OPC_Decode, 149, 12, 184, 1,               //  5125:            decode to MVE_VQMOVUNs16th using decoder 184
                                             //  5125:           }
  15, 0,                                     //  5130:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5132:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5134:            check Inst[4] == 0x0
  OPC_Decode, 134, 11, 184, 1,               //  5138:            decode to MVE_VMOVNi16th using decoder 184
                                             //  5138:           }
                                             //  5138:           } // switch Inst[31:28]
                                             //  5138:          }
                                             //  5138:          } // switch Inst[12]
                                             //  5138:         }
                                             //  5138:         } // switch Inst[7]
                                             //  5138:        }
  1, 109,                                    //  5143:        case 0x1: {
  OPC_SwitchField, 7, 1,                     //  5145:         switch Inst[7] {
  0, 65,                                     //  5148:         case 0x0: {
  OPC_SwitchField, 12, 1,                    //  5150:          switch Inst[12] {
  0, 29,                                     //  5153:          case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5155:           switch Inst[31:28] {
  14, 11,                                    //  5158:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5160:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5162:            check Inst[4] == 0x0
  OPC_Decode, 140, 12, 184, 1,               //  5166:            decode to MVE_VQMOVNs16bh using decoder 184
                                             //  5166:           }
  15, 0,                                     //  5171:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5173:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5175:            check Inst[4] == 0x0
  OPC_Decode, 144, 12, 184, 1,               //  5179:            decode to MVE_VQMOVNu16bh using decoder 184
                                             //  5179:           }
                                             //  5179:           } // switch Inst[31:28]
                                             //  5179:          }
  1, 0,                                      //  5184:          case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5186:           switch Inst[31:28] {
  14, 11,                                    //  5189:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5191:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5193:            check Inst[4] == 0x0
  OPC_Decode, 141, 12, 184, 1,               //  5197:            decode to MVE_VQMOVNs16th using decoder 184
                                             //  5197:           }
  15, 0,                                     //  5202:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5204:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5206:            check Inst[4] == 0x0
  OPC_Decode, 145, 12, 184, 1,               //  5210:            decode to MVE_VQMOVNu16th using decoder 184
                                             //  5210:           }
                                             //  5210:           } // switch Inst[31:28]
                                             //  5210:          }
                                             //  5210:          } // switch Inst[12]
                                             //  5210:         }
  1, 0,                                      //  5215:         case 0x1: {
  OPC_SwitchField, 12, 1,                    //  5217:          switch Inst[12] {
  0, 15,                                     //  5220:          case 0x0: {
  OPC_CheckPredicate, 31,                    //  5222:           check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  5224:           check Inst[31:28] == 0xe
  OPC_CheckField, 4, 1, 0,                   //  5228:           check Inst[4] == 0x0
  OPC_Decode, 150, 10, 184, 1,               //  5232:           decode to MVE_VMAXAs8 using decoder 184
                                             //  5232:          }
  1, 0,                                      //  5237:          case 0x1: {
  OPC_CheckPredicate, 31,                    //  5239:           check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  5241:           check Inst[31:28] == 0xe
  OPC_CheckField, 4, 1, 0,                   //  5245:           check Inst[4] == 0x0
  OPC_Decode, 176, 10, 184, 1,               //  5249:           decode to MVE_VMINAs8 using decoder 184
                                             //  5249:          }
                                             //  5249:          } // switch Inst[12]
                                             //  5249:         }
                                             //  5249:         } // switch Inst[7]
                                             //  5249:        }
  2, 137, 1,                                 //  5254:        case 0x2: {
  OPC_SwitchField, 7, 1,                     //  5257:         switch Inst[7] {
  0, 65,                                     //  5260:         case 0x0: {
  OPC_SwitchField, 12, 1,                    //  5262:          switch Inst[12] {
  0, 29,                                     //  5265:          case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5267:           switch Inst[31:28] {
  14, 11,                                    //  5270:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5272:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5274:            check Inst[4] == 0x0
  OPC_Decode, 193, 13, 183, 1,               //  5278:            decode to MVE_VSHLL_lws16bh using decoder 183
                                             //  5278:           }
  15, 0,                                     //  5283:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5285:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5287:            check Inst[4] == 0x0
  OPC_Decode, 197, 13, 183, 1,               //  5291:            decode to MVE_VSHLL_lwu16bh using decoder 183
                                             //  5291:           }
                                             //  5291:           } // switch Inst[31:28]
                                             //  5291:          }
  1, 0,                                      //  5296:          case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5298:           switch Inst[31:28] {
  14, 11,                                    //  5301:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5303:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5305:            check Inst[4] == 0x0
  OPC_Decode, 194, 13, 183, 1,               //  5309:            decode to MVE_VSHLL_lws16th using decoder 183
                                             //  5309:           }
  15, 0,                                     //  5314:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5316:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5318:            check Inst[4] == 0x0
  OPC_Decode, 198, 13, 183, 1,               //  5322:            decode to MVE_VSHLL_lwu16th using decoder 183
                                             //  5322:           }
                                             //  5322:           } // switch Inst[31:28]
                                             //  5322:          }
                                             //  5322:          } // switch Inst[12]
                                             //  5322:         }
  1, 0,                                      //  5327:         case 0x1: {
  OPC_SwitchField, 12, 1,                    //  5329:          switch Inst[12] {
  0, 29,                                     //  5332:          case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5334:           switch Inst[31:28] {
  14, 11,                                    //  5337:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5339:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5341:            check Inst[4] == 0x0
  OPC_Decode, 150, 12, 184, 1,               //  5345:            decode to MVE_VQMOVUNs32bh using decoder 184
                                             //  5345:           }
  15, 0,                                     //  5350:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5352:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5354:            check Inst[4] == 0x0
  OPC_Decode, 135, 11, 184, 1,               //  5358:            decode to MVE_VMOVNi32bh using decoder 184
                                             //  5358:           }
                                             //  5358:           } // switch Inst[31:28]
                                             //  5358:          }
  1, 0,                                      //  5363:          case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5365:           switch Inst[31:28] {
  14, 11,                                    //  5368:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5370:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5372:            check Inst[4] == 0x0
  OPC_Decode, 151, 12, 184, 1,               //  5376:            decode to MVE_VQMOVUNs32th using decoder 184
                                             //  5376:           }
  15, 0,                                     //  5381:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5383:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5385:            check Inst[4] == 0x0
  OPC_Decode, 136, 11, 184, 1,               //  5389:            decode to MVE_VMOVNi32th using decoder 184
                                             //  5389:           }
                                             //  5389:           } // switch Inst[31:28]
                                             //  5389:          }
                                             //  5389:          } // switch Inst[12]
                                             //  5389:         }
                                             //  5389:         } // switch Inst[7]
                                             //  5389:        }
  3, 109,                                    //  5394:        case 0x3: {
  OPC_SwitchField, 7, 1,                     //  5396:         switch Inst[7] {
  0, 65,                                     //  5399:         case 0x0: {
  OPC_SwitchField, 12, 1,                    //  5401:          switch Inst[12] {
  0, 29,                                     //  5404:          case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5406:           switch Inst[31:28] {
  14, 11,                                    //  5409:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5411:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5413:            check Inst[4] == 0x0
  OPC_Decode, 142, 12, 184, 1,               //  5417:            decode to MVE_VQMOVNs32bh using decoder 184
                                             //  5417:           }
  15, 0,                                     //  5422:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5424:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5426:            check Inst[4] == 0x0
  OPC_Decode, 146, 12, 184, 1,               //  5430:            decode to MVE_VQMOVNu32bh using decoder 184
                                             //  5430:           }
                                             //  5430:           } // switch Inst[31:28]
                                             //  5430:          }
  1, 0,                                      //  5435:          case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5437:           switch Inst[31:28] {
  14, 11,                                    //  5440:           case 0xe: {
  OPC_CheckPredicate, 31,                    //  5442:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5444:            check Inst[4] == 0x0
  OPC_Decode, 143, 12, 184, 1,               //  5448:            decode to MVE_VQMOVNs32th using decoder 184
                                             //  5448:           }
  15, 0,                                     //  5453:           case 0xf: {
  OPC_CheckPredicate, 31,                    //  5455:            check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  5457:            check Inst[4] == 0x0
  OPC_Decode, 147, 12, 184, 1,               //  5461:            decode to MVE_VQMOVNu32th using decoder 184
                                             //  5461:           }
                                             //  5461:           } // switch Inst[31:28]
                                             //  5461:          }
                                             //  5461:          } // switch Inst[12]
                                             //  5461:         }
  1, 0,                                      //  5466:         case 0x1: {
  OPC_SwitchField, 12, 1,                    //  5468:          switch Inst[12] {
  0, 15,                                     //  5471:          case 0x0: {
  OPC_CheckPredicate, 31,                    //  5473:           check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  5475:           check Inst[31:28] == 0xe
  OPC_CheckField, 4, 1, 0,                   //  5479:           check Inst[4] == 0x0
  OPC_Decode, 148, 10, 184, 1,               //  5483:           decode to MVE_VMAXAs16 using decoder 184
                                             //  5483:          }
  1, 0,                                      //  5488:          case 0x1: {
  OPC_CheckPredicate, 31,                    //  5490:           check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  5492:           check Inst[31:28] == 0xe
  OPC_CheckField, 4, 1, 0,                   //  5496:           check Inst[4] == 0x0
  OPC_Decode, 174, 10, 184, 1,               //  5500:           decode to MVE_VMINAs16 using decoder 184
                                             //  5500:          }
                                             //  5500:          } // switch Inst[12]
                                             //  5500:         }
                                             //  5500:         } // switch Inst[7]
                                             //  5500:        }
  5, 45,                                     //  5505:        case 0x5: {
  OPC_SwitchField, 12, 1,                    //  5507:         switch Inst[12] {
  0, 19,                                     //  5510:         case 0x0: {
  OPC_CheckPredicate, 31,                    //  5512:          check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  5514:          check Inst[31:28] == 0xe
  OPC_CheckField, 7, 1, 1,                   //  5518:          check Inst[7] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  5522:          check Inst[4] == 0x0
  OPC_Decode, 149, 10, 184, 1,               //  5526:          decode to MVE_VMAXAs32 using decoder 184
                                             //  5526:         }
  1, 0,                                      //  5531:         case 0x1: {
  OPC_CheckPredicate, 31,                    //  5533:          check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  5535:          check Inst[31:28] == 0xe
  OPC_CheckField, 7, 1, 1,                   //  5539:          check Inst[7] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  5543:          check Inst[4] == 0x0
  OPC_Decode, 175, 10, 184, 1,               //  5547:          decode to MVE_VMINAs32 using decoder 184
                                             //  5547:         }
                                             //  5547:         } // switch Inst[12]
                                             //  5547:        }
  7, 0,                                      //  5552:        case 0x7: {
  OPC_SwitchField, 7, 1,                     //  5554:         switch Inst[7] {
  0, 65,                                     //  5557:         case 0x0: {
  OPC_SwitchField, 12, 1,                    //  5559:          switch Inst[12] {
  0, 29,                                     //  5562:          case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5564:           switch Inst[31:28] {
  14, 11,                                    //  5567:           case 0xe: {
  OPC_CheckPredicate, 33,                    //  5569:            check predicate 33
  OPC_CheckField, 4, 1, 0,                   //  5571:            check Inst[4] == 0x0
  OPC_Decode, 232, 8, 184, 1,                //  5575:            decode to MVE_VCVTf16f32bh using decoder 184
                                             //  5575:           }
  15, 0,                                     //  5580:           case 0xf: {
  OPC_CheckPredicate, 33,                    //  5582:            check predicate 33
  OPC_CheckField, 4, 1, 0,                   //  5584:            check Inst[4] == 0x0
  OPC_Decode, 238, 8, 183, 1,                //  5588:            decode to MVE_VCVTf32f16bh using decoder 183
                                             //  5588:           }
                                             //  5588:           } // switch Inst[31:28]
                                             //  5588:          }
  1, 0,                                      //  5593:          case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5595:           switch Inst[31:28] {
  14, 11,                                    //  5598:           case 0xe: {
  OPC_CheckPredicate, 33,                    //  5600:            check predicate 33
  OPC_CheckField, 4, 1, 0,                   //  5602:            check Inst[4] == 0x0
  OPC_Decode, 233, 8, 184, 1,                //  5606:            decode to MVE_VCVTf16f32th using decoder 184
                                             //  5606:           }
  15, 0,                                     //  5611:           case 0xf: {
  OPC_CheckPredicate, 33,                    //  5613:            check predicate 33
  OPC_CheckField, 4, 1, 0,                   //  5615:            check Inst[4] == 0x0
  OPC_Decode, 239, 8, 183, 1,                //  5619:            decode to MVE_VCVTf32f16th using decoder 183
                                             //  5619:           }
                                             //  5619:           } // switch Inst[31:28]
                                             //  5619:          }
                                             //  5619:          } // switch Inst[12]
                                             //  5619:         }
  1, 0,                                      //  5624:         case 0x1: {
  OPC_SwitchField, 12, 1,                    //  5626:          switch Inst[12] {
  0, 29,                                     //  5629:          case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5631:           switch Inst[31:28] {
  14, 11,                                    //  5634:           case 0xe: {
  OPC_CheckPredicate, 33,                    //  5636:            check predicate 33
  OPC_CheckField, 4, 1, 0,                   //  5638:            check Inst[4] == 0x0
  OPC_Decode, 154, 10, 184, 1,               //  5642:            decode to MVE_VMAXNMAf32 using decoder 184
                                             //  5642:           }
  15, 0,                                     //  5647:           case 0xf: {
  OPC_CheckPredicate, 33,                    //  5649:            check predicate 33
  OPC_CheckField, 4, 1, 0,                   //  5651:            check Inst[4] == 0x0
  OPC_Decode, 153, 10, 184, 1,               //  5655:            decode to MVE_VMAXNMAf16 using decoder 184
                                             //  5655:           }
                                             //  5655:           } // switch Inst[31:28]
                                             //  5655:          }
  1, 0,                                      //  5660:          case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5662:           switch Inst[31:28] {
  14, 11,                                    //  5665:           case 0xe: {
  OPC_CheckPredicate, 33,                    //  5667:            check predicate 33
  OPC_CheckField, 4, 1, 0,                   //  5669:            check Inst[4] == 0x0
  OPC_Decode, 180, 10, 184, 1,               //  5673:            decode to MVE_VMINNMAf32 using decoder 184
                                             //  5673:           }
  15, 0,                                     //  5678:           case 0xf: {
  OPC_CheckPredicate, 33,                    //  5680:            check predicate 33
  OPC_CheckField, 4, 1, 0,                   //  5682:            check Inst[4] == 0x0
  OPC_Decode, 179, 10, 184, 1,               //  5686:            decode to MVE_VMINNMAf16 using decoder 184
                                             //  5686:           }
                                             //  5686:           } // switch Inst[31:28]
                                             //  5686:          }
                                             //  5686:          } // switch Inst[12]
                                             //  5686:         }
                                             //  5686:         } // switch Inst[7]
                                             //  5686:        }
                                             //  5686:        } // switch Inst[19:17]
                                             //  5686:       }
                                             //  5686:       } // switch Inst[0]
                                             //  5686:      }
                                             //  5686:      } // switch Inst[16]
                                             //  5686:     }
  1, 0,                                      //  5691:     case 0x1: {
  OPC_SwitchField, 4, 2,                     //  5693:      switch Inst[5:4] {
  0, 65,                                     //  5696:      case 0x0: {
  OPC_SwitchField, 12, 1,                    //  5698:       switch Inst[12] {
  0, 29,                                     //  5701:       case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5703:        switch Inst[31:28] {
  14, 11,                                    //  5706:        case 0xe: {
  OPC_CheckPredicate, 33,                    //  5708:         check predicate 33
  OPC_CheckField, 16, 1, 1,                  //  5710:         check Inst[16] == 0x1
  OPC_Decode, 153, 9, 180, 1,                //  5714:         decode to MVE_VFMA_qr_f32 using decoder 180
                                             //  5714:        }
  15, 0,                                     //  5719:        case 0xf: {
  OPC_CheckPredicate, 33,                    //  5721:         check predicate 33
  OPC_CheckField, 16, 1, 1,                  //  5723:         check Inst[16] == 0x1
  OPC_Decode, 152, 9, 180, 1,                //  5727:         decode to MVE_VFMA_qr_f16 using decoder 180
                                             //  5727:        }
                                             //  5727:        } // switch Inst[31:28]
                                             //  5727:       }
  1, 0,                                      //  5732:       case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5734:        switch Inst[31:28] {
  14, 11,                                    //  5737:        case 0xe: {
  OPC_CheckPredicate, 33,                    //  5739:         check predicate 33
  OPC_CheckField, 16, 1, 1,                  //  5741:         check Inst[16] == 0x1
  OPC_Decode, 151, 9, 180, 1,                //  5745:         decode to MVE_VFMA_qr_Sf32 using decoder 180
                                             //  5745:        }
  15, 0,                                     //  5750:        case 0xf: {
  OPC_CheckPredicate, 33,                    //  5752:         check predicate 33
  OPC_CheckField, 16, 1, 1,                  //  5754:         check Inst[16] == 0x1
  OPC_Decode, 150, 9, 180, 1,                //  5758:         decode to MVE_VFMA_qr_Sf16 using decoder 180
                                             //  5758:        }
                                             //  5758:        } // switch Inst[31:28]
                                             //  5758:       }
                                             //  5758:       } // switch Inst[12]
                                             //  5758:      }
  2, 0,                                      //  5763:      case 0x2: {
  OPC_SwitchField, 12, 1,                    //  5765:       switch Inst[12] {
  0, 29,                                     //  5768:       case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5770:        switch Inst[31:28] {
  14, 11,                                    //  5773:        case 0xe: {
  OPC_CheckPredicate, 33,                    //  5775:         check predicate 33
  OPC_CheckField, 16, 1, 1,                  //  5777:         check Inst[16] == 0x1
  OPC_Decode, 175, 11, 181, 1,               //  5781:         decode to MVE_VMUL_qr_f32 using decoder 181
                                             //  5781:        }
  15, 0,                                     //  5786:        case 0xf: {
  OPC_CheckPredicate, 33,                    //  5788:         check predicate 33
  OPC_CheckField, 16, 1, 1,                  //  5790:         check Inst[16] == 0x1
  OPC_Decode, 174, 11, 181, 1,               //  5794:         decode to MVE_VMUL_qr_f16 using decoder 181
                                             //  5794:        }
                                             //  5794:        } // switch Inst[31:28]
                                             //  5794:       }
  1, 0,                                      //  5799:       case 0x1: {
  OPC_SwitchField, 16, 4,                    //  5801:        switch Inst[19:16] {
  1, 49,                                     //  5804:        case 0x1: {
  OPC_SwitchField, 7, 1,                     //  5806:         switch Inst[7] {
  0, 21,                                     //  5809:         case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5811:          switch Inst[31:28] {
  14, 7,                                     //  5814:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  5816:           check predicate 31
  OPC_Decode, 212, 13, 185, 1,               //  5818:           decode to MVE_VSHL_qrs8 using decoder 185
                                             //  5818:          }
  15, 0,                                     //  5823:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  5825:           check predicate 31
  OPC_Decode, 215, 13, 185, 1,               //  5827:           decode to MVE_VSHL_qru8 using decoder 185
                                             //  5827:          }
                                             //  5827:          } // switch Inst[31:28]
                                             //  5827:         }
  1, 0,                                      //  5832:         case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5834:          switch Inst[31:28] {
  14, 7,                                     //  5837:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  5839:           check predicate 31
  OPC_Decode, 214, 12, 185, 1,               //  5841:           decode to MVE_VQSHL_qrs8 using decoder 185
                                             //  5841:          }
  15, 0,                                     //  5846:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  5848:           check predicate 31
  OPC_Decode, 217, 12, 185, 1,               //  5850:           decode to MVE_VQSHL_qru8 using decoder 185
                                             //  5850:          }
                                             //  5850:          } // switch Inst[31:28]
                                             //  5850:         }
                                             //  5850:         } // switch Inst[7]
                                             //  5850:        }
  3, 49,                                     //  5855:        case 0x3: {
  OPC_SwitchField, 7, 1,                     //  5857:         switch Inst[7] {
  0, 21,                                     //  5860:         case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5862:          switch Inst[31:28] {
  14, 7,                                     //  5865:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  5867:           check predicate 31
  OPC_Decode, 168, 13, 185, 1,               //  5869:           decode to MVE_VRSHL_qrs8 using decoder 185
                                             //  5869:          }
  15, 0,                                     //  5874:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  5876:           check predicate 31
  OPC_Decode, 171, 13, 185, 1,               //  5878:           decode to MVE_VRSHL_qru8 using decoder 185
                                             //  5878:          }
                                             //  5878:          } // switch Inst[31:28]
                                             //  5878:         }
  1, 0,                                      //  5883:         case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5885:          switch Inst[31:28] {
  14, 7,                                     //  5888:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  5890:           check predicate 31
  OPC_Decode, 187, 12, 185, 1,               //  5892:           decode to MVE_VQRSHL_qrs8 using decoder 185
                                             //  5892:          }
  15, 0,                                     //  5897:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  5899:           check predicate 31
  OPC_Decode, 190, 12, 185, 1,               //  5901:           decode to MVE_VQRSHL_qru8 using decoder 185
                                             //  5901:          }
                                             //  5901:          } // switch Inst[31:28]
                                             //  5901:         }
                                             //  5901:         } // switch Inst[7]
                                             //  5901:        }
  5, 49,                                     //  5906:        case 0x5: {
  OPC_SwitchField, 7, 1,                     //  5908:         switch Inst[7] {
  0, 21,                                     //  5911:         case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5913:          switch Inst[31:28] {
  14, 7,                                     //  5916:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  5918:           check predicate 31
  OPC_Decode, 210, 13, 185, 1,               //  5920:           decode to MVE_VSHL_qrs16 using decoder 185
                                             //  5920:          }
  15, 0,                                     //  5925:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  5927:           check predicate 31
  OPC_Decode, 213, 13, 185, 1,               //  5929:           decode to MVE_VSHL_qru16 using decoder 185
                                             //  5929:          }
                                             //  5929:          } // switch Inst[31:28]
                                             //  5929:         }
  1, 0,                                      //  5934:         case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5936:          switch Inst[31:28] {
  14, 7,                                     //  5939:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  5941:           check predicate 31
  OPC_Decode, 212, 12, 185, 1,               //  5943:           decode to MVE_VQSHL_qrs16 using decoder 185
                                             //  5943:          }
  15, 0,                                     //  5948:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  5950:           check predicate 31
  OPC_Decode, 215, 12, 185, 1,               //  5952:           decode to MVE_VQSHL_qru16 using decoder 185
                                             //  5952:          }
                                             //  5952:          } // switch Inst[31:28]
                                             //  5952:         }
                                             //  5952:         } // switch Inst[7]
                                             //  5952:        }
  7, 49,                                     //  5957:        case 0x7: {
  OPC_SwitchField, 7, 1,                     //  5959:         switch Inst[7] {
  0, 21,                                     //  5962:         case 0x0: {
  OPC_SwitchField, 28, 4,                    //  5964:          switch Inst[31:28] {
  14, 7,                                     //  5967:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  5969:           check predicate 31
  OPC_Decode, 166, 13, 185, 1,               //  5971:           decode to MVE_VRSHL_qrs16 using decoder 185
                                             //  5971:          }
  15, 0,                                     //  5976:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  5978:           check predicate 31
  OPC_Decode, 169, 13, 185, 1,               //  5980:           decode to MVE_VRSHL_qru16 using decoder 185
                                             //  5980:          }
                                             //  5980:          } // switch Inst[31:28]
                                             //  5980:         }
  1, 0,                                      //  5985:         case 0x1: {
  OPC_SwitchField, 28, 4,                    //  5987:          switch Inst[31:28] {
  14, 7,                                     //  5990:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  5992:           check predicate 31
  OPC_Decode, 185, 12, 185, 1,               //  5994:           decode to MVE_VQRSHL_qrs16 using decoder 185
                                             //  5994:          }
  15, 0,                                     //  5999:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  6001:           check predicate 31
  OPC_Decode, 188, 12, 185, 1,               //  6003:           decode to MVE_VQRSHL_qru16 using decoder 185
                                             //  6003:          }
                                             //  6003:          } // switch Inst[31:28]
                                             //  6003:         }
                                             //  6003:         } // switch Inst[7]
                                             //  6003:        }
  9, 49,                                     //  6008:        case 0x9: {
  OPC_SwitchField, 7, 1,                     //  6010:         switch Inst[7] {
  0, 21,                                     //  6013:         case 0x0: {
  OPC_SwitchField, 28, 4,                    //  6015:          switch Inst[31:28] {
  14, 7,                                     //  6018:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  6020:           check predicate 31
  OPC_Decode, 211, 13, 185, 1,               //  6022:           decode to MVE_VSHL_qrs32 using decoder 185
                                             //  6022:          }
  15, 0,                                     //  6027:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  6029:           check predicate 31
  OPC_Decode, 214, 13, 185, 1,               //  6031:           decode to MVE_VSHL_qru32 using decoder 185
                                             //  6031:          }
                                             //  6031:          } // switch Inst[31:28]
                                             //  6031:         }
  1, 0,                                      //  6036:         case 0x1: {
  OPC_SwitchField, 28, 4,                    //  6038:          switch Inst[31:28] {
  14, 7,                                     //  6041:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  6043:           check predicate 31
  OPC_Decode, 213, 12, 185, 1,               //  6045:           decode to MVE_VQSHL_qrs32 using decoder 185
                                             //  6045:          }
  15, 0,                                     //  6050:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  6052:           check predicate 31
  OPC_Decode, 216, 12, 185, 1,               //  6054:           decode to MVE_VQSHL_qru32 using decoder 185
                                             //  6054:          }
                                             //  6054:          } // switch Inst[31:28]
                                             //  6054:         }
                                             //  6054:         } // switch Inst[7]
                                             //  6054:        }
  11, 0,                                     //  6059:        case 0xb: {
  OPC_SwitchField, 7, 1,                     //  6061:         switch Inst[7] {
  0, 21,                                     //  6064:         case 0x0: {
  OPC_SwitchField, 28, 4,                    //  6066:          switch Inst[31:28] {
  14, 7,                                     //  6069:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  6071:           check predicate 31
  OPC_Decode, 167, 13, 185, 1,               //  6073:           decode to MVE_VRSHL_qrs32 using decoder 185
                                             //  6073:          }
  15, 0,                                     //  6078:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  6080:           check predicate 31
  OPC_Decode, 170, 13, 185, 1,               //  6082:           decode to MVE_VRSHL_qru32 using decoder 185
                                             //  6082:          }
                                             //  6082:          } // switch Inst[31:28]
                                             //  6082:         }
  1, 0,                                      //  6087:         case 0x1: {
  OPC_SwitchField, 28, 4,                    //  6089:          switch Inst[31:28] {
  14, 7,                                     //  6092:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  6094:           check predicate 31
  OPC_Decode, 186, 12, 185, 1,               //  6096:           decode to MVE_VQRSHL_qrs32 using decoder 185
                                             //  6096:          }
  15, 0,                                     //  6101:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  6103:           check predicate 31
  OPC_Decode, 189, 12, 185, 1,               //  6105:           decode to MVE_VQRSHL_qru32 using decoder 185
                                             //  6105:          }
                                             //  6105:          } // switch Inst[31:28]
                                             //  6105:         }
                                             //  6105:         } // switch Inst[7]
                                             //  6105:        }
                                             //  6105:        } // switch Inst[19:16]
                                             //  6105:       }
                                             //  6105:       } // switch Inst[12]
                                             //  6105:      }
                                             //  6105:      } // switch Inst[5:4]
                                             //  6105:     }
                                             //  6105:     } // switch Inst[6]
                                             //  6105:    }
                                             //  6105:    } // switch Inst[21:20]
                                             //  6105:   }
  15, 0,                                     //  6110:   case 0xf: {
  OPC_SwitchField, 20, 2,                    //  6112:    switch Inst[21:20] {
  0, 191, 3,                                 //  6115:    case 0x0: {
  OPC_SwitchField, 6, 1,                     //  6118:     switch Inst[6] {
  0, 154, 1,                                 //  6121:     case 0x0: {
  OPC_SwitchField, 16, 1,                    //  6124:      switch Inst[16] {
  0, 37,                                     //  6127:      case 0x0: {
  OPC_SwitchField, 28, 4,                    //  6129:       switch Inst[31:28] {
  14, 15,                                    //  6132:       case 0xe: {
  OPC_CheckPredicate, 31,                    //  6134:        check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  6136:        check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //  6140:        check Inst[0] == 0x0
  OPC_Decode, 172, 9, 186, 1,                //  6144:        decode to MVE_VHCADDs8 using decoder 186
                                             //  6144:       }
  15, 0,                                     //  6149:       case 0xf: {
  OPC_CheckPredicate, 31,                    //  6151:        check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  6153:        check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //  6157:        check Inst[0] == 0x0
  OPC_Decode, 195, 8, 186, 1,                //  6161:        decode to MVE_VCADDi8 using decoder 186
                                             //  6161:       }
                                             //  6161:       } // switch Inst[31:28]
                                             //  6161:      }
  1, 0,                                      //  6166:      case 0x1: {
  OPC_SwitchField, 12, 1,                    //  6168:       switch Inst[12] {
  0, 71,                                     //  6171:       case 0x0: {
  OPC_SwitchField, 0, 1,                     //  6173:        switch Inst[0] {
  0, 32,                                     //  6176:        case 0x0: {
  OPC_CheckField, 4, 1, 0,                   //  6178:         check Inst[4] == 0x0
  OPC_CheckField, 28, 4, 15,                 //  6182:         check Inst[31:28] == 0xf
  OPC_Scope, 15,                             //  6186:         try {
  OPC_CheckField, 13, 3, 0,                  //  6188:          check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6192:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6194:          check Inst[22] == 0x0
  OPC_Decode, 212, 8, 187, 1,                //  6198:          decode to MVE_VCMPi8 using decoder 187
                                             //  6198:         } else try {
  OPC_CheckPredicate, 31,                    //  6203:          check predicate 31
  OPC_Decode, 199, 11, 188, 1,               //  6205:          decode to MVE_VPTv16i8 using decoder 188
                                             //  6205:         }
                                             //  6205:        }
  1, 0,                                      //  6210:        case 0x1: {
  OPC_CheckField, 4, 1, 0,                   //  6212:         check Inst[4] == 0x0
  OPC_CheckField, 28, 4, 15,                 //  6216:         check Inst[31:28] == 0xf
  OPC_Scope, 15,                             //  6220:         try {
  OPC_CheckField, 13, 3, 0,                  //  6222:          check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6226:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6228:          check Inst[22] == 0x0
  OPC_Decode, 224, 8, 189, 1,                //  6232:          decode to MVE_VCMPu8 using decoder 189
                                             //  6232:         } else try {
  OPC_CheckPredicate, 31,                    //  6237:          check predicate 31
  OPC_Decode, 203, 11, 190, 1,               //  6239:          decode to MVE_VPTv16u8 using decoder 190
                                             //  6239:         }
                                             //  6239:        }
                                             //  6239:        } // switch Inst[0]
                                             //  6239:       }
  1, 0,                                      //  6244:       case 0x1: {
  OPC_CheckField, 4, 1, 0,                   //  6246:        check Inst[4] == 0x0
  OPC_CheckField, 28, 4, 15,                 //  6250:        check Inst[31:28] == 0xf
  OPC_Scope, 15,                             //  6254:        try {
  OPC_CheckField, 13, 3, 0,                  //  6256:         check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6260:         check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6262:         check Inst[22] == 0x0
  OPC_Decode, 218, 8, 191, 1,                //  6266:         decode to MVE_VCMPs8 using decoder 191
                                             //  6266:        } else try {
  OPC_CheckPredicate, 31,                    //  6271:         check predicate 31
  OPC_Decode, 201, 11, 192, 1,               //  6273:         decode to MVE_VPTv16s8 using decoder 192
                                             //  6273:        }
                                             //  6273:       }
                                             //  6273:       } // switch Inst[12]
                                             //  6273:      }
                                             //  6273:      } // switch Inst[16]
                                             //  6273:     }
  1, 0,                                      //  6278:     case 0x1: {
  OPC_SwitchField, 12, 1,                    //  6280:      switch Inst[12] {
  0, 152, 1,                                 //  6283:      case 0x0: {
  OPC_SwitchField, 4, 2,                     //  6286:       switch Inst[5:4] {
  0, 66,                                     //  6289:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  6291:        switch Inst[16] {
  0, 21,                                     //  6294:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  6296:         switch Inst[31:28] {
  14, 7,                                     //  6299:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  6301:          check predicate 31
  OPC_Decode, 160, 9, 181, 1,                //  6303:          decode to MVE_VHADD_qr_s8 using decoder 181
                                             //  6303:         }
  15, 0,                                     //  6308:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  6310:          check predicate 31
  OPC_Decode, 163, 9, 181, 1,                //  6312:          decode to MVE_VHADD_qr_u8 using decoder 181
                                             //  6312:         }
                                             //  6312:         } // switch Inst[31:28]
                                             //  6312:        }
  1, 0,                                      //  6317:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  6319:         switch Inst[31:28] {
  14, 7,                                     //  6322:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  6324:          check predicate 31
  OPC_Decode, 178, 8, 181, 1,                //  6326:          decode to MVE_VADD_qr_i8 using decoder 181
                                             //  6326:         }
  15, 0,                                     //  6331:         case 0xf: {
  OPC_Scope, 15,                             //  6333:          try {
  OPC_CheckField, 13, 3, 0,                  //  6335:           check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6339:           check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6341:           check Inst[22] == 0x0
  OPC_Decode, 213, 8, 193, 1,                //  6345:           decode to MVE_VCMPi8r using decoder 193
                                             //  6345:          } else try {
  OPC_CheckPredicate, 31,                    //  6350:           check predicate 31
  OPC_Decode, 200, 11, 194, 1,               //  6352:           decode to MVE_VPTv16i8r using decoder 194
                                             //  6352:          }
                                             //  6352:         }
                                             //  6352:         } // switch Inst[31:28]
                                             //  6352:        }
                                             //  6352:        } // switch Inst[16]
                                             //  6352:       }
  2, 0,                                      //  6357:       case 0x2: {
  OPC_SwitchField, 16, 1,                    //  6359:        switch Inst[16] {
  0, 21,                                     //  6362:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  6364:         switch Inst[31:28] {
  14, 7,                                     //  6367:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  6369:          check predicate 31
  OPC_Decode, 226, 11, 181, 1,               //  6371:          decode to MVE_VQADD_qr_s8 using decoder 181
                                             //  6371:         }
  15, 0,                                     //  6376:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  6378:          check predicate 31
  OPC_Decode, 229, 11, 181, 1,               //  6380:          decode to MVE_VQADD_qr_u8 using decoder 181
                                             //  6380:         }
                                             //  6380:         } // switch Inst[31:28]
                                             //  6380:        }
  1, 0,                                      //  6385:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  6387:         switch Inst[31:28] {
  14, 20,                                    //  6390:         case 0xe: {
  OPC_Scope, 11,                             //  6392:          try {
  OPC_CheckField, 1, 3, 7,                   //  6394:           check Inst[3:1] == 0x7
  OPC_CheckPredicate, 31,                    //  6398:           check predicate 31
  OPC_Decode, 187, 9, 195, 1,                //  6400:           decode to MVE_VIDUPu8 using decoder 195
                                             //  6400:          } else try {
  OPC_CheckPredicate, 31,                    //  6405:           check predicate 31
  OPC_Decode, 190, 9, 196, 1,                //  6407:           decode to MVE_VIWDUPu8 using decoder 196
                                             //  6407:          }
                                             //  6407:         }
  15, 0,                                     //  6412:         case 0xf: {
  OPC_Scope, 15,                             //  6414:          try {
  OPC_CheckField, 13, 3, 0,                  //  6416:           check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6420:           check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6422:           check Inst[22] == 0x0
  OPC_Decode, 225, 8, 197, 1,                //  6426:           decode to MVE_VCMPu8r using decoder 197
                                             //  6426:          } else try {
  OPC_CheckPredicate, 31,                    //  6431:           check predicate 31
  OPC_Decode, 204, 11, 198, 1,               //  6433:           decode to MVE_VPTv16u8r using decoder 198
                                             //  6433:          }
                                             //  6433:         }
                                             //  6433:         } // switch Inst[31:28]
                                             //  6433:        }
                                             //  6433:        } // switch Inst[16]
                                             //  6433:       }
                                             //  6433:       } // switch Inst[5:4]
                                             //  6433:      }
  1, 0,                                      //  6438:      case 0x1: {
  OPC_SwitchField, 16, 1,                    //  6440:       switch Inst[16] {
  0, 49,                                     //  6443:       case 0x0: {
  OPC_SwitchField, 4, 2,                     //  6445:        switch Inst[5:4] {
  0, 21,                                     //  6448:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  6450:         switch Inst[31:28] {
  14, 7,                                     //  6453:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  6455:          check predicate 31
  OPC_Decode, 175, 9, 181, 1,                //  6457:          decode to MVE_VHSUB_qr_s8 using decoder 181
                                             //  6457:         }
  15, 0,                                     //  6462:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  6464:          check predicate 31
  OPC_Decode, 178, 9, 181, 1,                //  6466:          decode to MVE_VHSUB_qr_u8 using decoder 181
                                             //  6466:         }
                                             //  6466:         } // switch Inst[31:28]
                                             //  6466:        }
  2, 0,                                      //  6471:        case 0x2: {
  OPC_SwitchField, 28, 4,                    //  6473:         switch Inst[31:28] {
  14, 7,                                     //  6476:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  6478:          check predicate 31
  OPC_Decode, 238, 12, 181, 1,               //  6480:          decode to MVE_VQSUB_qr_s8 using decoder 181
                                             //  6480:         }
  15, 0,                                     //  6485:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  6487:          check predicate 31
  OPC_Decode, 241, 12, 181, 1,               //  6489:          decode to MVE_VQSUB_qr_u8 using decoder 181
                                             //  6489:         }
                                             //  6489:         } // switch Inst[31:28]
                                             //  6489:        }
                                             //  6489:        } // switch Inst[5:4]
                                             //  6489:       }
  1, 0,                                      //  6494:       case 0x1: {
  OPC_SwitchField, 28, 4,                    //  6496:        switch Inst[31:28] {
  14, 34,                                    //  6499:        case 0xe: {
  OPC_SwitchField, 4, 2,                     //  6501:         switch Inst[5:4] {
  0, 7,                                      //  6504:         case 0x0: {
  OPC_CheckPredicate, 31,                    //  6506:          check predicate 31
  OPC_Decode, 177, 14, 181, 1,               //  6508:          decode to MVE_VSUB_qr_i8 using decoder 181
                                             //  6508:         }
  2, 0,                                      //  6513:         case 0x2: {
  OPC_Scope, 11,                             //  6515:          try {
  OPC_CheckField, 1, 3, 7,                   //  6517:           check Inst[3:1] == 0x7
  OPC_CheckPredicate, 31,                    //  6521:           check predicate 31
  OPC_Decode, 142, 9, 195, 1,                //  6523:           decode to MVE_VDDUPu8 using decoder 195
                                             //  6523:          } else try {
  OPC_CheckPredicate, 31,                    //  6528:           check predicate 31
  OPC_Decode, 148, 9, 196, 1,                //  6530:           decode to MVE_VDWDUPu8 using decoder 196
                                             //  6530:          }
                                             //  6530:         }
                                             //  6530:         } // switch Inst[5:4]
                                             //  6530:        }
  15, 0,                                     //  6535:        case 0xf: {
  OPC_CheckField, 4, 1, 0,                   //  6537:         check Inst[4] == 0x0
  OPC_Scope, 15,                             //  6541:         try {
  OPC_CheckField, 13, 3, 0,                  //  6543:          check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6547:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6549:          check Inst[22] == 0x0
  OPC_Decode, 219, 8, 199, 1,                //  6553:          decode to MVE_VCMPs8r using decoder 199
                                             //  6553:         } else try {
  OPC_CheckPredicate, 31,                    //  6558:          check predicate 31
  OPC_Decode, 202, 11, 200, 1,               //  6560:          decode to MVE_VPTv16s8r using decoder 200
                                             //  6560:         }
                                             //  6560:        }
                                             //  6560:        } // switch Inst[31:28]
                                             //  6560:       }
                                             //  6560:       } // switch Inst[16]
                                             //  6560:      }
                                             //  6560:      } // switch Inst[12]
                                             //  6560:     }
                                             //  6560:     } // switch Inst[6]
                                             //  6560:    }
  1, 191, 3,                                 //  6565:    case 0x1: {
  OPC_SwitchField, 6, 1,                     //  6568:     switch Inst[6] {
  0, 154, 1,                                 //  6571:     case 0x0: {
  OPC_SwitchField, 16, 1,                    //  6574:      switch Inst[16] {
  0, 37,                                     //  6577:      case 0x0: {
  OPC_SwitchField, 28, 4,                    //  6579:       switch Inst[31:28] {
  14, 15,                                    //  6582:       case 0xe: {
  OPC_CheckPredicate, 31,                    //  6584:        check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  6586:        check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //  6590:        check Inst[0] == 0x0
  OPC_Decode, 170, 9, 186, 1,                //  6594:        decode to MVE_VHCADDs16 using decoder 186
                                             //  6594:       }
  15, 0,                                     //  6599:       case 0xf: {
  OPC_CheckPredicate, 31,                    //  6601:        check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  6603:        check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //  6607:        check Inst[0] == 0x0
  OPC_Decode, 193, 8, 186, 1,                //  6611:        decode to MVE_VCADDi16 using decoder 186
                                             //  6611:       }
                                             //  6611:       } // switch Inst[31:28]
                                             //  6611:      }
  1, 0,                                      //  6616:      case 0x1: {
  OPC_SwitchField, 12, 1,                    //  6618:       switch Inst[12] {
  0, 71,                                     //  6621:       case 0x0: {
  OPC_SwitchField, 0, 1,                     //  6623:        switch Inst[0] {
  0, 32,                                     //  6626:        case 0x0: {
  OPC_CheckField, 4, 1, 0,                   //  6628:         check Inst[4] == 0x0
  OPC_CheckField, 28, 4, 15,                 //  6632:         check Inst[31:28] == 0xf
  OPC_Scope, 15,                             //  6636:         try {
  OPC_CheckField, 13, 3, 0,                  //  6638:          check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6642:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6644:          check Inst[22] == 0x0
  OPC_Decode, 208, 8, 187, 1,                //  6648:          decode to MVE_VCMPi16 using decoder 187
                                             //  6648:         } else try {
  OPC_CheckPredicate, 31,                    //  6653:          check predicate 31
  OPC_Decode, 215, 11, 188, 1,               //  6655:          decode to MVE_VPTv8i16 using decoder 188
                                             //  6655:         }
                                             //  6655:        }
  1, 0,                                      //  6660:        case 0x1: {
  OPC_CheckField, 4, 1, 0,                   //  6662:         check Inst[4] == 0x0
  OPC_CheckField, 28, 4, 15,                 //  6666:         check Inst[31:28] == 0xf
  OPC_Scope, 15,                             //  6670:         try {
  OPC_CheckField, 13, 3, 0,                  //  6672:          check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6676:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6678:          check Inst[22] == 0x0
  OPC_Decode, 220, 8, 189, 1,                //  6682:          decode to MVE_VCMPu16 using decoder 189
                                             //  6682:         } else try {
  OPC_CheckPredicate, 31,                    //  6687:          check predicate 31
  OPC_Decode, 219, 11, 190, 1,               //  6689:          decode to MVE_VPTv8u16 using decoder 190
                                             //  6689:         }
                                             //  6689:        }
                                             //  6689:        } // switch Inst[0]
                                             //  6689:       }
  1, 0,                                      //  6694:       case 0x1: {
  OPC_CheckField, 4, 1, 0,                   //  6696:        check Inst[4] == 0x0
  OPC_CheckField, 28, 4, 15,                 //  6700:        check Inst[31:28] == 0xf
  OPC_Scope, 15,                             //  6704:        try {
  OPC_CheckField, 13, 3, 0,                  //  6706:         check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6710:         check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6712:         check Inst[22] == 0x0
  OPC_Decode, 214, 8, 191, 1,                //  6716:         decode to MVE_VCMPs16 using decoder 191
                                             //  6716:        } else try {
  OPC_CheckPredicate, 31,                    //  6721:         check predicate 31
  OPC_Decode, 217, 11, 192, 1,               //  6723:         decode to MVE_VPTv8s16 using decoder 192
                                             //  6723:        }
                                             //  6723:       }
                                             //  6723:       } // switch Inst[12]
                                             //  6723:      }
                                             //  6723:      } // switch Inst[16]
                                             //  6723:     }
  1, 0,                                      //  6728:     case 0x1: {
  OPC_SwitchField, 12, 1,                    //  6730:      switch Inst[12] {
  0, 152, 1,                                 //  6733:      case 0x0: {
  OPC_SwitchField, 4, 2,                     //  6736:       switch Inst[5:4] {
  0, 66,                                     //  6739:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  6741:        switch Inst[16] {
  0, 21,                                     //  6744:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  6746:         switch Inst[31:28] {
  14, 7,                                     //  6749:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  6751:          check predicate 31
  OPC_Decode, 158, 9, 181, 1,                //  6753:          decode to MVE_VHADD_qr_s16 using decoder 181
                                             //  6753:         }
  15, 0,                                     //  6758:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  6760:          check predicate 31
  OPC_Decode, 161, 9, 181, 1,                //  6762:          decode to MVE_VHADD_qr_u16 using decoder 181
                                             //  6762:         }
                                             //  6762:         } // switch Inst[31:28]
                                             //  6762:        }
  1, 0,                                      //  6767:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  6769:         switch Inst[31:28] {
  14, 7,                                     //  6772:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  6774:          check predicate 31
  OPC_Decode, 176, 8, 181, 1,                //  6776:          decode to MVE_VADD_qr_i16 using decoder 181
                                             //  6776:         }
  15, 0,                                     //  6781:         case 0xf: {
  OPC_Scope, 15,                             //  6783:          try {
  OPC_CheckField, 13, 3, 0,                  //  6785:           check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6789:           check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6791:           check Inst[22] == 0x0
  OPC_Decode, 209, 8, 193, 1,                //  6795:           decode to MVE_VCMPi16r using decoder 193
                                             //  6795:          } else try {
  OPC_CheckPredicate, 31,                    //  6800:           check predicate 31
  OPC_Decode, 216, 11, 194, 1,               //  6802:           decode to MVE_VPTv8i16r using decoder 194
                                             //  6802:          }
                                             //  6802:         }
                                             //  6802:         } // switch Inst[31:28]
                                             //  6802:        }
                                             //  6802:        } // switch Inst[16]
                                             //  6802:       }
  2, 0,                                      //  6807:       case 0x2: {
  OPC_SwitchField, 16, 1,                    //  6809:        switch Inst[16] {
  0, 21,                                     //  6812:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  6814:         switch Inst[31:28] {
  14, 7,                                     //  6817:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  6819:          check predicate 31
  OPC_Decode, 224, 11, 181, 1,               //  6821:          decode to MVE_VQADD_qr_s16 using decoder 181
                                             //  6821:         }
  15, 0,                                     //  6826:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  6828:          check predicate 31
  OPC_Decode, 227, 11, 181, 1,               //  6830:          decode to MVE_VQADD_qr_u16 using decoder 181
                                             //  6830:         }
                                             //  6830:         } // switch Inst[31:28]
                                             //  6830:        }
  1, 0,                                      //  6835:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  6837:         switch Inst[31:28] {
  14, 20,                                    //  6840:         case 0xe: {
  OPC_Scope, 11,                             //  6842:          try {
  OPC_CheckField, 1, 3, 7,                   //  6844:           check Inst[3:1] == 0x7
  OPC_CheckPredicate, 31,                    //  6848:           check predicate 31
  OPC_Decode, 185, 9, 195, 1,                //  6850:           decode to MVE_VIDUPu16 using decoder 195
                                             //  6850:          } else try {
  OPC_CheckPredicate, 31,                    //  6855:           check predicate 31
  OPC_Decode, 188, 9, 196, 1,                //  6857:           decode to MVE_VIWDUPu16 using decoder 196
                                             //  6857:          }
                                             //  6857:         }
  15, 0,                                     //  6862:         case 0xf: {
  OPC_Scope, 15,                             //  6864:          try {
  OPC_CheckField, 13, 3, 0,                  //  6866:           check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6870:           check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6872:           check Inst[22] == 0x0
  OPC_Decode, 221, 8, 197, 1,                //  6876:           decode to MVE_VCMPu16r using decoder 197
                                             //  6876:          } else try {
  OPC_CheckPredicate, 31,                    //  6881:           check predicate 31
  OPC_Decode, 220, 11, 198, 1,               //  6883:           decode to MVE_VPTv8u16r using decoder 198
                                             //  6883:          }
                                             //  6883:         }
                                             //  6883:         } // switch Inst[31:28]
                                             //  6883:        }
                                             //  6883:        } // switch Inst[16]
                                             //  6883:       }
                                             //  6883:       } // switch Inst[5:4]
                                             //  6883:      }
  1, 0,                                      //  6888:      case 0x1: {
  OPC_SwitchField, 16, 1,                    //  6890:       switch Inst[16] {
  0, 49,                                     //  6893:       case 0x0: {
  OPC_SwitchField, 4, 2,                     //  6895:        switch Inst[5:4] {
  0, 21,                                     //  6898:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  6900:         switch Inst[31:28] {
  14, 7,                                     //  6903:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  6905:          check predicate 31
  OPC_Decode, 173, 9, 181, 1,                //  6907:          decode to MVE_VHSUB_qr_s16 using decoder 181
                                             //  6907:         }
  15, 0,                                     //  6912:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  6914:          check predicate 31
  OPC_Decode, 176, 9, 181, 1,                //  6916:          decode to MVE_VHSUB_qr_u16 using decoder 181
                                             //  6916:         }
                                             //  6916:         } // switch Inst[31:28]
                                             //  6916:        }
  2, 0,                                      //  6921:        case 0x2: {
  OPC_SwitchField, 28, 4,                    //  6923:         switch Inst[31:28] {
  14, 7,                                     //  6926:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  6928:          check predicate 31
  OPC_Decode, 236, 12, 181, 1,               //  6930:          decode to MVE_VQSUB_qr_s16 using decoder 181
                                             //  6930:         }
  15, 0,                                     //  6935:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  6937:          check predicate 31
  OPC_Decode, 239, 12, 181, 1,               //  6939:          decode to MVE_VQSUB_qr_u16 using decoder 181
                                             //  6939:         }
                                             //  6939:         } // switch Inst[31:28]
                                             //  6939:        }
                                             //  6939:        } // switch Inst[5:4]
                                             //  6939:       }
  1, 0,                                      //  6944:       case 0x1: {
  OPC_SwitchField, 28, 4,                    //  6946:        switch Inst[31:28] {
  14, 34,                                    //  6949:        case 0xe: {
  OPC_SwitchField, 4, 2,                     //  6951:         switch Inst[5:4] {
  0, 7,                                      //  6954:         case 0x0: {
  OPC_CheckPredicate, 31,                    //  6956:          check predicate 31
  OPC_Decode, 175, 14, 181, 1,               //  6958:          decode to MVE_VSUB_qr_i16 using decoder 181
                                             //  6958:         }
  2, 0,                                      //  6963:         case 0x2: {
  OPC_Scope, 11,                             //  6965:          try {
  OPC_CheckField, 1, 3, 7,                   //  6967:           check Inst[3:1] == 0x7
  OPC_CheckPredicate, 31,                    //  6971:           check predicate 31
  OPC_Decode, 140, 9, 195, 1,                //  6973:           decode to MVE_VDDUPu16 using decoder 195
                                             //  6973:          } else try {
  OPC_CheckPredicate, 31,                    //  6978:           check predicate 31
  OPC_Decode, 146, 9, 196, 1,                //  6980:           decode to MVE_VDWDUPu16 using decoder 196
                                             //  6980:          }
                                             //  6980:         }
                                             //  6980:         } // switch Inst[5:4]
                                             //  6980:        }
  15, 0,                                     //  6985:        case 0xf: {
  OPC_CheckField, 4, 1, 0,                   //  6987:         check Inst[4] == 0x0
  OPC_Scope, 15,                             //  6991:         try {
  OPC_CheckField, 13, 3, 0,                  //  6993:          check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  6997:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  6999:          check Inst[22] == 0x0
  OPC_Decode, 215, 8, 199, 1,                //  7003:          decode to MVE_VCMPs16r using decoder 199
                                             //  7003:         } else try {
  OPC_CheckPredicate, 31,                    //  7008:          check predicate 31
  OPC_Decode, 218, 11, 200, 1,               //  7010:          decode to MVE_VPTv8s16r using decoder 200
                                             //  7010:         }
                                             //  7010:        }
                                             //  7010:        } // switch Inst[31:28]
                                             //  7010:       }
                                             //  7010:       } // switch Inst[16]
                                             //  7010:      }
                                             //  7010:      } // switch Inst[12]
                                             //  7010:     }
                                             //  7010:     } // switch Inst[6]
                                             //  7010:    }
  2, 191, 3,                                 //  7015:    case 0x2: {
  OPC_SwitchField, 6, 1,                     //  7018:     switch Inst[6] {
  0, 154, 1,                                 //  7021:     case 0x0: {
  OPC_SwitchField, 16, 1,                    //  7024:      switch Inst[16] {
  0, 37,                                     //  7027:      case 0x0: {
  OPC_SwitchField, 28, 4,                    //  7029:       switch Inst[31:28] {
  14, 15,                                    //  7032:       case 0xe: {
  OPC_CheckPredicate, 31,                    //  7034:        check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  7036:        check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //  7040:        check Inst[0] == 0x0
  OPC_Decode, 171, 9, 186, 1,                //  7044:        decode to MVE_VHCADDs32 using decoder 186
                                             //  7044:       }
  15, 0,                                     //  7049:       case 0xf: {
  OPC_CheckPredicate, 31,                    //  7051:        check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  7053:        check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   //  7057:        check Inst[0] == 0x0
  OPC_Decode, 194, 8, 186, 1,                //  7061:        decode to MVE_VCADDi32 using decoder 186
                                             //  7061:       }
                                             //  7061:       } // switch Inst[31:28]
                                             //  7061:      }
  1, 0,                                      //  7066:      case 0x1: {
  OPC_SwitchField, 12, 1,                    //  7068:       switch Inst[12] {
  0, 71,                                     //  7071:       case 0x0: {
  OPC_SwitchField, 0, 1,                     //  7073:        switch Inst[0] {
  0, 32,                                     //  7076:        case 0x0: {
  OPC_CheckField, 4, 1, 0,                   //  7078:         check Inst[4] == 0x0
  OPC_CheckField, 28, 4, 15,                 //  7082:         check Inst[31:28] == 0xf
  OPC_Scope, 15,                             //  7086:         try {
  OPC_CheckField, 13, 3, 0,                  //  7088:          check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  7092:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  7094:          check Inst[22] == 0x0
  OPC_Decode, 210, 8, 187, 1,                //  7098:          decode to MVE_VCMPi32 using decoder 187
                                             //  7098:         } else try {
  OPC_CheckPredicate, 31,                    //  7103:          check predicate 31
  OPC_Decode, 207, 11, 188, 1,               //  7105:          decode to MVE_VPTv4i32 using decoder 188
                                             //  7105:         }
                                             //  7105:        }
  1, 0,                                      //  7110:        case 0x1: {
  OPC_CheckField, 4, 1, 0,                   //  7112:         check Inst[4] == 0x0
  OPC_CheckField, 28, 4, 15,                 //  7116:         check Inst[31:28] == 0xf
  OPC_Scope, 15,                             //  7120:         try {
  OPC_CheckField, 13, 3, 0,                  //  7122:          check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  7126:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  7128:          check Inst[22] == 0x0
  OPC_Decode, 222, 8, 189, 1,                //  7132:          decode to MVE_VCMPu32 using decoder 189
                                             //  7132:         } else try {
  OPC_CheckPredicate, 31,                    //  7137:          check predicate 31
  OPC_Decode, 211, 11, 190, 1,               //  7139:          decode to MVE_VPTv4u32 using decoder 190
                                             //  7139:         }
                                             //  7139:        }
                                             //  7139:        } // switch Inst[0]
                                             //  7139:       }
  1, 0,                                      //  7144:       case 0x1: {
  OPC_CheckField, 4, 1, 0,                   //  7146:        check Inst[4] == 0x0
  OPC_CheckField, 28, 4, 15,                 //  7150:        check Inst[31:28] == 0xf
  OPC_Scope, 15,                             //  7154:        try {
  OPC_CheckField, 13, 3, 0,                  //  7156:         check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  7160:         check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  7162:         check Inst[22] == 0x0
  OPC_Decode, 216, 8, 191, 1,                //  7166:         decode to MVE_VCMPs32 using decoder 191
                                             //  7166:        } else try {
  OPC_CheckPredicate, 31,                    //  7171:         check predicate 31
  OPC_Decode, 209, 11, 192, 1,               //  7173:         decode to MVE_VPTv4s32 using decoder 192
                                             //  7173:        }
                                             //  7173:       }
                                             //  7173:       } // switch Inst[12]
                                             //  7173:      }
                                             //  7173:      } // switch Inst[16]
                                             //  7173:     }
  1, 0,                                      //  7178:     case 0x1: {
  OPC_SwitchField, 12, 1,                    //  7180:      switch Inst[12] {
  0, 152, 1,                                 //  7183:      case 0x0: {
  OPC_SwitchField, 4, 2,                     //  7186:       switch Inst[5:4] {
  0, 66,                                     //  7189:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  7191:        switch Inst[16] {
  0, 21,                                     //  7194:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  7196:         switch Inst[31:28] {
  14, 7,                                     //  7199:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  7201:          check predicate 31
  OPC_Decode, 159, 9, 181, 1,                //  7203:          decode to MVE_VHADD_qr_s32 using decoder 181
                                             //  7203:         }
  15, 0,                                     //  7208:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  7210:          check predicate 31
  OPC_Decode, 162, 9, 181, 1,                //  7212:          decode to MVE_VHADD_qr_u32 using decoder 181
                                             //  7212:         }
                                             //  7212:         } // switch Inst[31:28]
                                             //  7212:        }
  1, 0,                                      //  7217:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  7219:         switch Inst[31:28] {
  14, 7,                                     //  7222:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  7224:          check predicate 31
  OPC_Decode, 177, 8, 181, 1,                //  7226:          decode to MVE_VADD_qr_i32 using decoder 181
                                             //  7226:         }
  15, 0,                                     //  7231:         case 0xf: {
  OPC_Scope, 15,                             //  7233:          try {
  OPC_CheckField, 13, 3, 0,                  //  7235:           check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  7239:           check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  7241:           check Inst[22] == 0x0
  OPC_Decode, 211, 8, 193, 1,                //  7245:           decode to MVE_VCMPi32r using decoder 193
                                             //  7245:          } else try {
  OPC_CheckPredicate, 31,                    //  7250:           check predicate 31
  OPC_Decode, 208, 11, 194, 1,               //  7252:           decode to MVE_VPTv4i32r using decoder 194
                                             //  7252:          }
                                             //  7252:         }
                                             //  7252:         } // switch Inst[31:28]
                                             //  7252:        }
                                             //  7252:        } // switch Inst[16]
                                             //  7252:       }
  2, 0,                                      //  7257:       case 0x2: {
  OPC_SwitchField, 16, 1,                    //  7259:        switch Inst[16] {
  0, 21,                                     //  7262:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  7264:         switch Inst[31:28] {
  14, 7,                                     //  7267:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  7269:          check predicate 31
  OPC_Decode, 225, 11, 181, 1,               //  7271:          decode to MVE_VQADD_qr_s32 using decoder 181
                                             //  7271:         }
  15, 0,                                     //  7276:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  7278:          check predicate 31
  OPC_Decode, 228, 11, 181, 1,               //  7280:          decode to MVE_VQADD_qr_u32 using decoder 181
                                             //  7280:         }
                                             //  7280:         } // switch Inst[31:28]
                                             //  7280:        }
  1, 0,                                      //  7285:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  7287:         switch Inst[31:28] {
  14, 20,                                    //  7290:         case 0xe: {
  OPC_Scope, 11,                             //  7292:          try {
  OPC_CheckField, 1, 3, 7,                   //  7294:           check Inst[3:1] == 0x7
  OPC_CheckPredicate, 31,                    //  7298:           check predicate 31
  OPC_Decode, 186, 9, 195, 1,                //  7300:           decode to MVE_VIDUPu32 using decoder 195
                                             //  7300:          } else try {
  OPC_CheckPredicate, 31,                    //  7305:           check predicate 31
  OPC_Decode, 189, 9, 196, 1,                //  7307:           decode to MVE_VIWDUPu32 using decoder 196
                                             //  7307:          }
                                             //  7307:         }
  15, 0,                                     //  7312:         case 0xf: {
  OPC_Scope, 15,                             //  7314:          try {
  OPC_CheckField, 13, 3, 0,                  //  7316:           check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  7320:           check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  7322:           check Inst[22] == 0x0
  OPC_Decode, 223, 8, 197, 1,                //  7326:           decode to MVE_VCMPu32r using decoder 197
                                             //  7326:          } else try {
  OPC_CheckPredicate, 31,                    //  7331:           check predicate 31
  OPC_Decode, 212, 11, 198, 1,               //  7333:           decode to MVE_VPTv4u32r using decoder 198
                                             //  7333:          }
                                             //  7333:         }
                                             //  7333:         } // switch Inst[31:28]
                                             //  7333:        }
                                             //  7333:        } // switch Inst[16]
                                             //  7333:       }
                                             //  7333:       } // switch Inst[5:4]
                                             //  7333:      }
  1, 0,                                      //  7338:      case 0x1: {
  OPC_SwitchField, 16, 1,                    //  7340:       switch Inst[16] {
  0, 49,                                     //  7343:       case 0x0: {
  OPC_SwitchField, 4, 2,                     //  7345:        switch Inst[5:4] {
  0, 21,                                     //  7348:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  7350:         switch Inst[31:28] {
  14, 7,                                     //  7353:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  7355:          check predicate 31
  OPC_Decode, 174, 9, 181, 1,                //  7357:          decode to MVE_VHSUB_qr_s32 using decoder 181
                                             //  7357:         }
  15, 0,                                     //  7362:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  7364:          check predicate 31
  OPC_Decode, 177, 9, 181, 1,                //  7366:          decode to MVE_VHSUB_qr_u32 using decoder 181
                                             //  7366:         }
                                             //  7366:         } // switch Inst[31:28]
                                             //  7366:        }
  2, 0,                                      //  7371:        case 0x2: {
  OPC_SwitchField, 28, 4,                    //  7373:         switch Inst[31:28] {
  14, 7,                                     //  7376:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  7378:          check predicate 31
  OPC_Decode, 237, 12, 181, 1,               //  7380:          decode to MVE_VQSUB_qr_s32 using decoder 181
                                             //  7380:         }
  15, 0,                                     //  7385:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  7387:          check predicate 31
  OPC_Decode, 240, 12, 181, 1,               //  7389:          decode to MVE_VQSUB_qr_u32 using decoder 181
                                             //  7389:         }
                                             //  7389:         } // switch Inst[31:28]
                                             //  7389:        }
                                             //  7389:        } // switch Inst[5:4]
                                             //  7389:       }
  1, 0,                                      //  7394:       case 0x1: {
  OPC_SwitchField, 28, 4,                    //  7396:        switch Inst[31:28] {
  14, 34,                                    //  7399:        case 0xe: {
  OPC_SwitchField, 4, 2,                     //  7401:         switch Inst[5:4] {
  0, 7,                                      //  7404:         case 0x0: {
  OPC_CheckPredicate, 31,                    //  7406:          check predicate 31
  OPC_Decode, 176, 14, 181, 1,               //  7408:          decode to MVE_VSUB_qr_i32 using decoder 181
                                             //  7408:         }
  2, 0,                                      //  7413:         case 0x2: {
  OPC_Scope, 11,                             //  7415:          try {
  OPC_CheckField, 1, 3, 7,                   //  7417:           check Inst[3:1] == 0x7
  OPC_CheckPredicate, 31,                    //  7421:           check predicate 31
  OPC_Decode, 141, 9, 195, 1,                //  7423:           decode to MVE_VDDUPu32 using decoder 195
                                             //  7423:          } else try {
  OPC_CheckPredicate, 31,                    //  7428:           check predicate 31
  OPC_Decode, 147, 9, 196, 1,                //  7430:           decode to MVE_VDWDUPu32 using decoder 196
                                             //  7430:          }
                                             //  7430:         }
                                             //  7430:         } // switch Inst[5:4]
                                             //  7430:        }
  15, 0,                                     //  7435:        case 0xf: {
  OPC_CheckField, 4, 1, 0,                   //  7437:         check Inst[4] == 0x0
  OPC_Scope, 15,                             //  7441:         try {
  OPC_CheckField, 13, 3, 0,                  //  7443:          check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  7447:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  7449:          check Inst[22] == 0x0
  OPC_Decode, 217, 8, 199, 1,                //  7453:          decode to MVE_VCMPs32r using decoder 199
                                             //  7453:         } else try {
  OPC_CheckPredicate, 31,                    //  7458:          check predicate 31
  OPC_Decode, 210, 11, 200, 1,               //  7460:          decode to MVE_VPTv4s32r using decoder 200
                                             //  7460:         }
                                             //  7460:        }
                                             //  7460:        } // switch Inst[31:28]
                                             //  7460:       }
                                             //  7460:       } // switch Inst[16]
                                             //  7460:      }
                                             //  7460:      } // switch Inst[12]
                                             //  7460:     }
                                             //  7460:     } // switch Inst[6]
                                             //  7460:    }
  3, 0,                                      //  7465:    case 0x3: {
  OPC_SwitchField, 6, 1,                     //  7467:     switch Inst[6] {
  0, 225, 1,                                 //  7470:     case 0x0: {
  OPC_SwitchField, 16, 1,                    //  7473:      switch Inst[16] {
  0, 137, 1,                                 //  7476:      case 0x0: {
  OPC_SwitchField, 0, 1,                     //  7479:       switch Inst[0] {
  0, 65,                                     //  7482:       case 0x0: {
  OPC_SwitchField, 12, 1,                    //  7484:        switch Inst[12] {
  0, 29,                                     //  7487:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  7489:         switch Inst[31:28] {
  14, 11,                                    //  7492:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  7494:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  7496:          check Inst[4] == 0x0
  OPC_Decode, 156, 8, 201, 1,                //  7500:          decode to MVE_VADC using decoder 201
                                             //  7500:         }
  15, 0,                                     //  7505:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  7507:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  7509:          check Inst[4] == 0x0
  OPC_Decode, 182, 13, 201, 1,               //  7513:          decode to MVE_VSBC using decoder 201
                                             //  7513:         }
                                             //  7513:         } // switch Inst[31:28]
                                             //  7513:        }
  1, 0,                                      //  7518:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  7520:         switch Inst[31:28] {
  14, 11,                                    //  7523:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  7525:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  7527:          check Inst[4] == 0x0
  OPC_Decode, 157, 8, 201, 1,                //  7531:          decode to MVE_VADCI using decoder 201
                                             //  7531:         }
  15, 0,                                     //  7536:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  7538:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  7540:          check Inst[4] == 0x0
  OPC_Decode, 183, 13, 201, 1,               //  7544:          decode to MVE_VSBCI using decoder 201
                                             //  7544:         }
                                             //  7544:         } // switch Inst[31:28]
                                             //  7544:        }
                                             //  7544:        } // switch Inst[12]
                                             //  7544:       }
  1, 0,                                      //  7549:       case 0x1: {
  OPC_SwitchField, 12, 1,                    //  7551:        switch Inst[12] {
  0, 29,                                     //  7554:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  7556:         switch Inst[31:28] {
  14, 11,                                    //  7559:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  7561:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  7563:          check Inst[4] == 0x0
  OPC_Decode, 136, 12, 179, 1,               //  7567:          decode to MVE_VQDMULLs16bh using decoder 179
                                             //  7567:         }
  15, 0,                                     //  7572:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  7574:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  7576:          check Inst[4] == 0x0
  OPC_Decode, 138, 12, 179, 1,               //  7580:          decode to MVE_VQDMULLs32bh using decoder 179
                                             //  7580:         }
                                             //  7580:         } // switch Inst[31:28]
                                             //  7580:        }
  1, 0,                                      //  7585:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  7587:         switch Inst[31:28] {
  14, 11,                                    //  7590:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  7592:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  7594:          check Inst[4] == 0x0
  OPC_Decode, 137, 12, 179, 1,               //  7598:          decode to MVE_VQDMULLs16th using decoder 179
                                             //  7598:         }
  15, 0,                                     //  7603:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  7605:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  7607:          check Inst[4] == 0x0
  OPC_Decode, 139, 12, 179, 1,               //  7611:          decode to MVE_VQDMULLs32th using decoder 179
                                             //  7611:         }
                                             //  7611:         } // switch Inst[31:28]
                                             //  7611:        }
                                             //  7611:        } // switch Inst[12]
                                             //  7611:       }
                                             //  7611:       } // switch Inst[0]
                                             //  7611:      }
  1, 0,                                      //  7616:      case 0x1: {
  OPC_SwitchField, 28, 4,                    //  7618:       switch Inst[31:28] {
  14, 28,                                    //  7621:       case 0xe: {
  OPC_CheckField, 4, 1, 0,                   //  7623:        check Inst[4] == 0x0
  OPC_Scope, 15,                             //  7627:        try {
  OPC_CheckField, 13, 3, 0,                  //  7629:         check Inst[15:13] == 0x0
  OPC_CheckPredicate, 33,                    //  7633:         check predicate 33
  OPC_CheckField, 22, 1, 0,                  //  7635:         check Inst[22] == 0x0
  OPC_Decode, 206, 8, 202, 1,                //  7639:         decode to MVE_VCMPf32 using decoder 202
                                             //  7639:        } else try {
  OPC_CheckPredicate, 33,                    //  7644:         check predicate 33
  OPC_Decode, 205, 11, 203, 1,               //  7646:         decode to MVE_VPTv4f32 using decoder 203
                                             //  7646:        }
                                             //  7646:       }
  15, 0,                                     //  7651:       case 0xf: {
  OPC_CheckField, 4, 1, 0,                   //  7653:        check Inst[4] == 0x0
  OPC_Scope, 15,                             //  7657:        try {
  OPC_CheckField, 0, 1, 1,                   //  7659:         check Inst[0] == 0x1
  OPC_CheckPredicate, 31,                    //  7663:         check predicate 31
  OPC_CheckField, 12, 1, 0,                  //  7665:         check Inst[12] == 0x0
  OPC_Decode, 197, 11, 204, 1,               //  7669:         decode to MVE_VPSEL using decoder 204
  OPC_Scope, 15,                             //  7674:        } else try {
  OPC_CheckField, 13, 3, 0,                  //  7676:         check Inst[15:13] == 0x0
  OPC_CheckPredicate, 33,                    //  7680:         check predicate 33
  OPC_CheckField, 22, 1, 0,                  //  7682:         check Inst[22] == 0x0
  OPC_Decode, 204, 8, 202, 1,                //  7686:         decode to MVE_VCMPf16 using decoder 202
                                             //  7686:        } else try {
  OPC_CheckPredicate, 33,                    //  7691:         check predicate 33
  OPC_Decode, 213, 11, 203, 1,               //  7693:         decode to MVE_VPTv8f16 using decoder 203
                                             //  7693:        }
                                             //  7693:       }
                                             //  7693:       } // switch Inst[31:28]
                                             //  7693:      }
                                             //  7693:      } // switch Inst[16]
                                             //  7693:     }
  1, 0,                                      //  7698:     case 0x1: {
  OPC_SwitchField, 16, 1,                    //  7700:      switch Inst[16] {
  0, 105,                                    //  7703:      case 0x0: {
  OPC_SwitchField, 4, 2,                     //  7705:       switch Inst[5:4] {
  0, 49,                                     //  7708:       case 0x0: {
  OPC_SwitchField, 12, 1,                    //  7710:        switch Inst[12] {
  0, 21,                                     //  7713:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  7715:         switch Inst[31:28] {
  14, 7,                                     //  7718:         case 0xe: {
  OPC_CheckPredicate, 33,                    //  7720:          check predicate 33
  OPC_Decode, 175, 8, 181, 1,                //  7722:          decode to MVE_VADD_qr_f32 using decoder 181
                                             //  7722:         }
  15, 0,                                     //  7727:         case 0xf: {
  OPC_CheckPredicate, 33,                    //  7729:          check predicate 33
  OPC_Decode, 174, 8, 181, 1,                //  7731:          decode to MVE_VADD_qr_f16 using decoder 181
                                             //  7731:         }
                                             //  7731:         } // switch Inst[31:28]
                                             //  7731:        }
  1, 0,                                      //  7736:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  7738:         switch Inst[31:28] {
  14, 7,                                     //  7741:         case 0xe: {
  OPC_CheckPredicate, 33,                    //  7743:          check predicate 33
  OPC_Decode, 174, 14, 181, 1,               //  7745:          decode to MVE_VSUB_qr_f32 using decoder 181
                                             //  7745:         }
  15, 0,                                     //  7750:         case 0xf: {
  OPC_CheckPredicate, 33,                    //  7752:          check predicate 33
  OPC_Decode, 173, 14, 181, 1,               //  7754:          decode to MVE_VSUB_qr_f16 using decoder 181
                                             //  7754:         }
                                             //  7754:         } // switch Inst[31:28]
                                             //  7754:        }
                                             //  7754:        } // switch Inst[12]
                                             //  7754:       }
  2, 0,                                      //  7759:       case 0x2: {
  OPC_SwitchField, 12, 1,                    //  7761:        switch Inst[12] {
  0, 21,                                     //  7764:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  7766:         switch Inst[31:28] {
  14, 7,                                     //  7769:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  7771:          check predicate 31
  OPC_Decode, 132, 12, 181, 1,               //  7773:          decode to MVE_VQDMULL_qr_s16bh using decoder 181
                                             //  7773:         }
  15, 0,                                     //  7778:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  7780:          check predicate 31
  OPC_Decode, 134, 12, 181, 1,               //  7782:          decode to MVE_VQDMULL_qr_s32bh using decoder 181
                                             //  7782:         }
                                             //  7782:         } // switch Inst[31:28]
                                             //  7782:        }
  1, 0,                                      //  7787:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  7789:         switch Inst[31:28] {
  14, 7,                                     //  7792:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  7794:          check predicate 31
  OPC_Decode, 133, 12, 181, 1,               //  7796:          decode to MVE_VQDMULL_qr_s16th using decoder 181
                                             //  7796:         }
  15, 0,                                     //  7801:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  7803:          check predicate 31
  OPC_Decode, 135, 12, 181, 1,               //  7805:          decode to MVE_VQDMULL_qr_s32th using decoder 181
                                             //  7805:         }
                                             //  7805:         } // switch Inst[31:28]
                                             //  7805:        }
                                             //  7805:        } // switch Inst[12]
                                             //  7805:       }
                                             //  7805:       } // switch Inst[5:4]
                                             //  7805:      }
  1, 0,                                      //  7810:      case 0x1: {
  OPC_SwitchField, 28, 4,                    //  7812:       switch Inst[31:28] {
  14, 28,                                    //  7815:       case 0xe: {
  OPC_CheckField, 4, 1, 0,                   //  7817:        check Inst[4] == 0x0
  OPC_Scope, 15,                             //  7821:        try {
  OPC_CheckField, 13, 3, 0,                  //  7823:         check Inst[15:13] == 0x0
  OPC_CheckPredicate, 33,                    //  7827:         check predicate 33
  OPC_CheckField, 22, 1, 0,                  //  7829:         check Inst[22] == 0x0
  OPC_Decode, 207, 8, 205, 1,                //  7833:         decode to MVE_VCMPf32r using decoder 205
                                             //  7833:        } else try {
  OPC_CheckPredicate, 33,                    //  7838:         check predicate 33
  OPC_Decode, 206, 11, 206, 1,               //  7840:         decode to MVE_VPTv4f32r using decoder 206
                                             //  7840:        }
                                             //  7840:       }
  15, 0,                                     //  7845:       case 0xf: {
  OPC_CheckField, 4, 1, 0,                   //  7847:        check Inst[4] == 0x0
  OPC_Scope, 41,                             //  7851:        try {
  OPC_CheckField, 0, 4, 13,                  //  7853:         check Inst[3:0] == 0xd
  OPC_Scope, 20,                             //  7857:         try {
  OPC_CheckField, 13, 3, 0,                  //  7859:          check Inst[15:13] == 0x0
  OPC_CheckPredicate, 31,                    //  7863:          check predicate 31
  OPC_CheckField, 22, 1, 0,                  //  7865:          check Inst[22] == 0x0
  OPC_SoftFail, 160, 161, 56, 0,             //  7869:          softfail pos=0x000e10a0 neg=0x00000000
  OPC_Decode, 196, 11, 207, 1,               //  7874:          decode to MVE_VPNOT using decoder 207
                                             //  7874:         } else try {
  OPC_CheckPredicate, 31,                    //  7879:          check predicate 31
  OPC_CheckField, 17, 3, 0,                  //  7881:          check Inst[19:17] == 0x0
  OPC_SoftFail, 160, 33, 0,                  //  7885:          softfail pos=0x000010a0 neg=0x00000000
  OPC_Decode, 198, 11, 208, 1,               //  7889:          decode to MVE_VPST using decoder 208
                                             //  7889:         }
  OPC_Scope, 15,                             //  7894:        } else try {
  OPC_CheckField, 13, 3, 0,                  //  7896:         check Inst[15:13] == 0x0
  OPC_CheckPredicate, 33,                    //  7900:         check predicate 33
  OPC_CheckField, 22, 1, 0,                  //  7902:         check Inst[22] == 0x0
  OPC_Decode, 205, 8, 205, 1,                //  7906:         decode to MVE_VCMPf16r using decoder 205
                                             //  7906:        } else try {
  OPC_CheckPredicate, 33,                    //  7911:         check predicate 33
  OPC_Decode, 214, 11, 206, 1,               //  7913:         decode to MVE_VPTv8f16r using decoder 206
                                             //  7913:        }
                                             //  7913:       }
                                             //  7913:       } // switch Inst[31:28]
                                             //  7913:      }
                                             //  7913:      } // switch Inst[16]
                                             //  7913:     }
                                             //  7913:     } // switch Inst[6]
                                             //  7913:    }
                                             //  7913:    } // switch Inst[21:20]
                                             //  7913:   }
                                             //  7913:   } // switch Inst[11:8]
                                             //  7913:  }
  1, 208, 20,                                //  7918:  case 0x1: {
  OPC_SwitchField, 8, 4,                     //  7921:   switch Inst[11:8] {
  11, 107,                                   //  7924:   case 0xb: {
  OPC_SwitchField, 20, 1,                    //  7926:    switch Inst[20] {
  0, 63,                                     //  7929:    case 0x0: {
  OPC_SwitchField, 0, 7,                     //  7931:     switch Inst[6:0] {
  16, 37,                                    //  7934:     case 0x10: {
  OPC_SwitchField, 21, 2,                    //  7936:      switch Inst[22:21] {
  1, 15,                                     //  7939:      case 0x1: {
  OPC_CheckPredicate, 31,                    //  7941:       check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  7943:       check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  //  7947:       check Inst[16] == 0x0
  OPC_Decode, 144, 9, 209, 1,                //  7951:       decode to MVE_VDUP32 using decoder 209
                                             //  7951:      }
  3, 0,                                      //  7956:      case 0x3: {
  OPC_CheckPredicate, 31,                    //  7958:       check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  7960:       check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  //  7964:       check Inst[16] == 0x0
  OPC_Decode, 145, 9, 209, 1,                //  7968:       decode to MVE_VDUP8 using decoder 209
                                             //  7968:      }
                                             //  7968:      } // switch Inst[22:21]
                                             //  7968:     }
  48, 0,                                     //  7973:     case 0x30: {
  OPC_CheckPredicate, 31,                    //  7975:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  7977:      check Inst[31:28] == 0xe
  OPC_CheckField, 21, 2, 1,                  //  7981:      check Inst[22:21] == 0x1
  OPC_CheckField, 16, 1, 0,                  //  7985:      check Inst[16] == 0x0
  OPC_Decode, 143, 9, 209, 1,                //  7989:      decode to MVE_VDUP16 using decoder 209
                                             //  7989:     }
                                             //  7989:     } // switch Inst[6:0]
                                             //  7989:    }
  1, 0,                                      //  7994:    case 0x1: {
  OPC_SwitchField, 22, 1,                    //  7996:     switch Inst[22] {
  0, 15,                                     //  7999:     case 0x0: {
  OPC_CheckPredicate, 32,                    //  8001:      check predicate 32
  OPC_CheckField, 28, 4, 14,                 //  8003:      check Inst[31:28] == 0xe
  OPC_CheckField, 0, 6, 48,                  //  8007:      check Inst[5:0] == 0x30
  OPC_Decode, 140, 11, 176, 1,               //  8011:      decode to MVE_VMOV_from_lane_u16 using decoder 176
                                             //  8011:     }
  1, 0,                                      //  8016:     case 0x1: {
  OPC_CheckPredicate, 32,                    //  8018:      check predicate 32
  OPC_CheckField, 28, 4, 14,                 //  8020:      check Inst[31:28] == 0xe
  OPC_CheckField, 0, 5, 16,                  //  8024:      check Inst[4:0] == 0x10
  OPC_Decode, 141, 11, 177, 1,               //  8028:      decode to MVE_VMOV_from_lane_u8 using decoder 177
                                             //  8028:     }
                                             //  8028:     } // switch Inst[22]
                                             //  8028:    }
                                             //  8028:    } // switch Inst[20]
                                             //  8028:   }
  14, 164, 5,                                //  8033:   case 0xe: {
  OPC_SwitchField, 0, 1,                     //  8036:    switch Inst[0] {
  0, 206, 2,                                 //  8039:    case 0x0: {
  OPC_SwitchField, 4, 4,                     //  8042:     switch Inst[7:4] {
  0, 163, 1,                                 //  8045:     case 0x0: {
  OPC_SwitchField, 12, 1,                    //  8048:      switch Inst[12] {
  0, 101,                                    //  8051:      case 0x0: {
  OPC_SwitchField, 16, 1,                    //  8053:       switch Inst[16] {
  0, 47,                                     //  8056:       case 0x0: {
  OPC_SwitchField, 28, 4,                    //  8058:        switch Inst[31:28] {
  14, 20,                                    //  8061:        case 0xe: {
  OPC_Scope, 11,                             //  8063:         try {
  OPC_CheckField, 20, 3, 7,                  //  8065:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8069:          check predicate 31
  OPC_Decode, 206, 10, 210, 1,               //  8071:          decode to MVE_VMLADAVs16 using decoder 210
                                             //  8071:         } else try {
  OPC_CheckPredicate, 31,                    //  8076:          check predicate 31
  OPC_Decode, 221, 10, 211, 1,               //  8078:          decode to MVE_VMLALDAVs16 using decoder 211
                                             //  8078:         }
                                             //  8078:        }
  15, 0,                                     //  8083:        case 0xf: {
  OPC_Scope, 11,                             //  8085:         try {
  OPC_CheckField, 20, 3, 7,                  //  8087:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8091:          check predicate 31
  OPC_Decode, 209, 10, 210, 1,               //  8093:          decode to MVE_VMLADAVu16 using decoder 210
                                             //  8093:         } else try {
  OPC_CheckPredicate, 31,                    //  8098:          check predicate 31
  OPC_Decode, 223, 10, 211, 1,               //  8100:          decode to MVE_VMLALDAVu16 using decoder 211
                                             //  8100:         }
                                             //  8100:        }
                                             //  8100:        } // switch Inst[31:28]
                                             //  8100:       }
  1, 0,                                      //  8105:       case 0x1: {
  OPC_SwitchField, 28, 4,                    //  8107:        switch Inst[31:28] {
  14, 20,                                    //  8110:        case 0xe: {
  OPC_Scope, 11,                             //  8112:         try {
  OPC_CheckField, 20, 3, 7,                  //  8114:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8118:          check predicate 31
  OPC_Decode, 207, 10, 210, 1,               //  8120:          decode to MVE_VMLADAVs32 using decoder 210
                                             //  8120:         } else try {
  OPC_CheckPredicate, 31,                    //  8125:          check predicate 31
  OPC_Decode, 222, 10, 211, 1,               //  8127:          decode to MVE_VMLALDAVs32 using decoder 211
                                             //  8127:         }
                                             //  8127:        }
  15, 0,                                     //  8132:        case 0xf: {
  OPC_Scope, 11,                             //  8134:         try {
  OPC_CheckField, 20, 3, 7,                  //  8136:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8140:          check predicate 31
  OPC_Decode, 210, 10, 210, 1,               //  8142:          decode to MVE_VMLADAVu32 using decoder 210
                                             //  8142:         } else try {
  OPC_CheckPredicate, 31,                    //  8147:          check predicate 31
  OPC_Decode, 224, 10, 211, 1,               //  8149:          decode to MVE_VMLALDAVu32 using decoder 211
                                             //  8149:         }
                                             //  8149:        }
                                             //  8149:        } // switch Inst[31:28]
                                             //  8149:       }
                                             //  8149:       } // switch Inst[16]
                                             //  8149:      }
  1, 0,                                      //  8154:      case 0x1: {
  OPC_SwitchField, 16, 1,                    //  8156:       switch Inst[16] {
  0, 24,                                     //  8159:       case 0x0: {
  OPC_CheckField, 28, 4, 14,                 //  8161:        check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //  8165:        try {
  OPC_CheckField, 20, 3, 7,                  //  8167:         check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8171:         check predicate 31
  OPC_Decode, 212, 10, 210, 1,               //  8173:         decode to MVE_VMLADAVxs16 using decoder 210
                                             //  8173:        } else try {
  OPC_CheckPredicate, 31,                    //  8178:         check predicate 31
  OPC_Decode, 225, 10, 211, 1,               //  8180:         decode to MVE_VMLALDAVxs16 using decoder 211
                                             //  8180:        }
                                             //  8180:       }
  1, 0,                                      //  8185:       case 0x1: {
  OPC_CheckField, 28, 4, 14,                 //  8187:        check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //  8191:        try {
  OPC_CheckField, 20, 3, 7,                  //  8193:         check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8197:         check predicate 31
  OPC_Decode, 213, 10, 210, 1,               //  8199:         decode to MVE_VMLADAVxs32 using decoder 210
                                             //  8199:        } else try {
  OPC_CheckPredicate, 31,                    //  8204:         check predicate 31
  OPC_Decode, 226, 10, 211, 1,               //  8206:         decode to MVE_VMLALDAVxs32 using decoder 211
                                             //  8206:        }
                                             //  8206:       }
                                             //  8206:       } // switch Inst[16]
                                             //  8206:      }
                                             //  8206:      } // switch Inst[12]
                                             //  8206:     }
  2, 0,                                      //  8211:     case 0x2: {
  OPC_SwitchField, 12, 1,                    //  8213:      switch Inst[12] {
  0, 101,                                    //  8216:      case 0x0: {
  OPC_SwitchField, 16, 1,                    //  8218:       switch Inst[16] {
  0, 47,                                     //  8221:       case 0x0: {
  OPC_SwitchField, 28, 4,                    //  8223:        switch Inst[31:28] {
  14, 20,                                    //  8226:        case 0xe: {
  OPC_Scope, 11,                             //  8228:         try {
  OPC_CheckField, 20, 3, 7,                  //  8230:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8234:          check predicate 31
  OPC_Decode, 197, 10, 212, 1,               //  8236:          decode to MVE_VMLADAVas16 using decoder 212
                                             //  8236:         } else try {
  OPC_CheckPredicate, 31,                    //  8241:          check predicate 31
  OPC_Decode, 215, 10, 213, 1,               //  8243:          decode to MVE_VMLALDAVas16 using decoder 213
                                             //  8243:         }
                                             //  8243:        }
  15, 0,                                     //  8248:        case 0xf: {
  OPC_Scope, 11,                             //  8250:         try {
  OPC_CheckField, 20, 3, 7,                  //  8252:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8256:          check predicate 31
  OPC_Decode, 200, 10, 212, 1,               //  8258:          decode to MVE_VMLADAVau16 using decoder 212
                                             //  8258:         } else try {
  OPC_CheckPredicate, 31,                    //  8263:          check predicate 31
  OPC_Decode, 217, 10, 213, 1,               //  8265:          decode to MVE_VMLALDAVau16 using decoder 213
                                             //  8265:         }
                                             //  8265:        }
                                             //  8265:        } // switch Inst[31:28]
                                             //  8265:       }
  1, 0,                                      //  8270:       case 0x1: {
  OPC_SwitchField, 28, 4,                    //  8272:        switch Inst[31:28] {
  14, 20,                                    //  8275:        case 0xe: {
  OPC_Scope, 11,                             //  8277:         try {
  OPC_CheckField, 20, 3, 7,                  //  8279:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8283:          check predicate 31
  OPC_Decode, 198, 10, 212, 1,               //  8285:          decode to MVE_VMLADAVas32 using decoder 212
                                             //  8285:         } else try {
  OPC_CheckPredicate, 31,                    //  8290:          check predicate 31
  OPC_Decode, 216, 10, 213, 1,               //  8292:          decode to MVE_VMLALDAVas32 using decoder 213
                                             //  8292:         }
                                             //  8292:        }
  15, 0,                                     //  8297:        case 0xf: {
  OPC_Scope, 11,                             //  8299:         try {
  OPC_CheckField, 20, 3, 7,                  //  8301:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8305:          check predicate 31
  OPC_Decode, 201, 10, 212, 1,               //  8307:          decode to MVE_VMLADAVau32 using decoder 212
                                             //  8307:         } else try {
  OPC_CheckPredicate, 31,                    //  8312:          check predicate 31
  OPC_Decode, 218, 10, 213, 1,               //  8314:          decode to MVE_VMLALDAVau32 using decoder 213
                                             //  8314:         }
                                             //  8314:        }
                                             //  8314:        } // switch Inst[31:28]
                                             //  8314:       }
                                             //  8314:       } // switch Inst[16]
                                             //  8314:      }
  1, 0,                                      //  8319:      case 0x1: {
  OPC_SwitchField, 16, 1,                    //  8321:       switch Inst[16] {
  0, 24,                                     //  8324:       case 0x0: {
  OPC_CheckField, 28, 4, 14,                 //  8326:        check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //  8330:        try {
  OPC_CheckField, 20, 3, 7,                  //  8332:         check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8336:         check predicate 31
  OPC_Decode, 203, 10, 212, 1,               //  8338:         decode to MVE_VMLADAVaxs16 using decoder 212
                                             //  8338:        } else try {
  OPC_CheckPredicate, 31,                    //  8343:         check predicate 31
  OPC_Decode, 219, 10, 213, 1,               //  8345:         decode to MVE_VMLALDAVaxs16 using decoder 213
                                             //  8345:        }
                                             //  8345:       }
  1, 0,                                      //  8350:       case 0x1: {
  OPC_CheckField, 28, 4, 14,                 //  8352:        check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //  8356:        try {
  OPC_CheckField, 20, 3, 7,                  //  8358:         check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8362:         check predicate 31
  OPC_Decode, 204, 10, 212, 1,               //  8364:         decode to MVE_VMLADAVaxs32 using decoder 212
                                             //  8364:        } else try {
  OPC_CheckPredicate, 31,                    //  8369:         check predicate 31
  OPC_Decode, 220, 10, 213, 1,               //  8371:         decode to MVE_VMLALDAVaxs32 using decoder 213
                                             //  8371:        }
                                             //  8371:       }
                                             //  8371:       } // switch Inst[16]
                                             //  8371:      }
                                             //  8371:      } // switch Inst[12]
                                             //  8371:     }
                                             //  8371:     } // switch Inst[7:4]
                                             //  8371:    }
  1, 0,                                      //  8376:    case 0x1: {
  OPC_SwitchField, 4, 4,                     //  8378:     switch Inst[7:4] {
  0, 163, 1,                                 //  8381:     case 0x0: {
  OPC_SwitchField, 12, 1,                    //  8384:      switch Inst[12] {
  0, 78,                                     //  8387:      case 0x0: {
  OPC_SwitchField, 16, 1,                    //  8389:       switch Inst[16] {
  0, 47,                                     //  8392:       case 0x0: {
  OPC_SwitchField, 28, 4,                    //  8394:        switch Inst[31:28] {
  14, 20,                                    //  8397:        case 0xe: {
  OPC_Scope, 11,                             //  8399:         try {
  OPC_CheckField, 20, 3, 7,                  //  8401:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8405:          check predicate 31
  OPC_Decode, 239, 10, 210, 1,               //  8407:          decode to MVE_VMLSDAVs16 using decoder 210
                                             //  8407:         } else try {
  OPC_CheckPredicate, 31,                    //  8412:          check predicate 31
  OPC_Decode, 249, 10, 211, 1,               //  8414:          decode to MVE_VMLSLDAVs16 using decoder 211
                                             //  8414:         }
                                             //  8414:        }
  15, 0,                                     //  8419:        case 0xf: {
  OPC_Scope, 11,                             //  8421:         try {
  OPC_CheckField, 20, 3, 7,                  //  8423:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8427:          check predicate 31
  OPC_Decode, 241, 10, 210, 1,               //  8429:          decode to MVE_VMLSDAVs8 using decoder 210
                                             //  8429:         } else try {
  OPC_CheckPredicate, 31,                    //  8434:          check predicate 31
  OPC_Decode, 152, 13, 211, 1,               //  8436:          decode to MVE_VRMLSLDAVHs32 using decoder 211
                                             //  8436:         }
                                             //  8436:        }
                                             //  8436:        } // switch Inst[31:28]
                                             //  8436:       }
  1, 0,                                      //  8441:       case 0x1: {
  OPC_CheckField, 28, 4, 14,                 //  8443:        check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //  8447:        try {
  OPC_CheckField, 20, 3, 7,                  //  8449:         check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8453:         check predicate 31
  OPC_Decode, 240, 10, 210, 1,               //  8455:         decode to MVE_VMLSDAVs32 using decoder 210
                                             //  8455:        } else try {
  OPC_CheckPredicate, 31,                    //  8460:         check predicate 31
  OPC_Decode, 250, 10, 211, 1,               //  8462:         decode to MVE_VMLSLDAVs32 using decoder 211
                                             //  8462:        }
                                             //  8462:       }
                                             //  8462:       } // switch Inst[16]
                                             //  8462:      }
  1, 0,                                      //  8467:      case 0x1: {
  OPC_SwitchField, 16, 1,                    //  8469:       switch Inst[16] {
  0, 47,                                     //  8472:       case 0x0: {
  OPC_SwitchField, 28, 4,                    //  8474:        switch Inst[31:28] {
  14, 20,                                    //  8477:        case 0xe: {
  OPC_Scope, 11,                             //  8479:         try {
  OPC_CheckField, 20, 3, 7,                  //  8481:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8485:          check predicate 31
  OPC_Decode, 242, 10, 210, 1,               //  8487:          decode to MVE_VMLSDAVxs16 using decoder 210
                                             //  8487:         } else try {
  OPC_CheckPredicate, 31,                    //  8492:          check predicate 31
  OPC_Decode, 251, 10, 211, 1,               //  8494:          decode to MVE_VMLSLDAVxs16 using decoder 211
                                             //  8494:         }
                                             //  8494:        }
  15, 0,                                     //  8499:        case 0xf: {
  OPC_Scope, 11,                             //  8501:         try {
  OPC_CheckField, 20, 3, 7,                  //  8503:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8507:          check predicate 31
  OPC_Decode, 244, 10, 210, 1,               //  8509:          decode to MVE_VMLSDAVxs8 using decoder 210
                                             //  8509:         } else try {
  OPC_CheckPredicate, 31,                    //  8514:          check predicate 31
  OPC_Decode, 153, 13, 211, 1,               //  8516:          decode to MVE_VRMLSLDAVHxs32 using decoder 211
                                             //  8516:         }
                                             //  8516:        }
                                             //  8516:        } // switch Inst[31:28]
                                             //  8516:       }
  1, 0,                                      //  8521:       case 0x1: {
  OPC_CheckField, 28, 4, 14,                 //  8523:        check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //  8527:        try {
  OPC_CheckField, 20, 3, 7,                  //  8529:         check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8533:         check predicate 31
  OPC_Decode, 243, 10, 210, 1,               //  8535:         decode to MVE_VMLSDAVxs32 using decoder 210
                                             //  8535:        } else try {
  OPC_CheckPredicate, 31,                    //  8540:         check predicate 31
  OPC_Decode, 252, 10, 211, 1,               //  8542:         decode to MVE_VMLSLDAVxs32 using decoder 211
                                             //  8542:        }
                                             //  8542:       }
                                             //  8542:       } // switch Inst[16]
                                             //  8542:      }
                                             //  8542:      } // switch Inst[12]
                                             //  8542:     }
  2, 0,                                      //  8547:     case 0x2: {
  OPC_SwitchField, 12, 1,                    //  8549:      switch Inst[12] {
  0, 78,                                     //  8552:      case 0x0: {
  OPC_SwitchField, 16, 1,                    //  8554:       switch Inst[16] {
  0, 47,                                     //  8557:       case 0x0: {
  OPC_SwitchField, 28, 4,                    //  8559:        switch Inst[31:28] {
  14, 20,                                    //  8562:        case 0xe: {
  OPC_Scope, 11,                             //  8564:         try {
  OPC_CheckField, 20, 3, 7,                  //  8566:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8570:          check predicate 31
  OPC_Decode, 233, 10, 212, 1,               //  8572:          decode to MVE_VMLSDAVas16 using decoder 212
                                             //  8572:         } else try {
  OPC_CheckPredicate, 31,                    //  8577:          check predicate 31
  OPC_Decode, 245, 10, 213, 1,               //  8579:          decode to MVE_VMLSLDAVas16 using decoder 213
                                             //  8579:         }
                                             //  8579:        }
  15, 0,                                     //  8584:        case 0xf: {
  OPC_Scope, 11,                             //  8586:         try {
  OPC_CheckField, 20, 3, 7,                  //  8588:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8592:          check predicate 31
  OPC_Decode, 235, 10, 212, 1,               //  8594:          decode to MVE_VMLSDAVas8 using decoder 212
                                             //  8594:         } else try {
  OPC_CheckPredicate, 31,                    //  8599:          check predicate 31
  OPC_Decode, 150, 13, 213, 1,               //  8601:          decode to MVE_VRMLSLDAVHas32 using decoder 213
                                             //  8601:         }
                                             //  8601:        }
                                             //  8601:        } // switch Inst[31:28]
                                             //  8601:       }
  1, 0,                                      //  8606:       case 0x1: {
  OPC_CheckField, 28, 4, 14,                 //  8608:        check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //  8612:        try {
  OPC_CheckField, 20, 3, 7,                  //  8614:         check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8618:         check predicate 31
  OPC_Decode, 234, 10, 212, 1,               //  8620:         decode to MVE_VMLSDAVas32 using decoder 212
                                             //  8620:        } else try {
  OPC_CheckPredicate, 31,                    //  8625:         check predicate 31
  OPC_Decode, 246, 10, 213, 1,               //  8627:         decode to MVE_VMLSLDAVas32 using decoder 213
                                             //  8627:        }
                                             //  8627:       }
                                             //  8627:       } // switch Inst[16]
                                             //  8627:      }
  1, 0,                                      //  8632:      case 0x1: {
  OPC_SwitchField, 16, 1,                    //  8634:       switch Inst[16] {
  0, 47,                                     //  8637:       case 0x0: {
  OPC_SwitchField, 28, 4,                    //  8639:        switch Inst[31:28] {
  14, 20,                                    //  8642:        case 0xe: {
  OPC_Scope, 11,                             //  8644:         try {
  OPC_CheckField, 20, 3, 7,                  //  8646:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8650:          check predicate 31
  OPC_Decode, 236, 10, 212, 1,               //  8652:          decode to MVE_VMLSDAVaxs16 using decoder 212
                                             //  8652:         } else try {
  OPC_CheckPredicate, 31,                    //  8657:          check predicate 31
  OPC_Decode, 247, 10, 213, 1,               //  8659:          decode to MVE_VMLSLDAVaxs16 using decoder 213
                                             //  8659:         }
                                             //  8659:        }
  15, 0,                                     //  8664:        case 0xf: {
  OPC_Scope, 11,                             //  8666:         try {
  OPC_CheckField, 20, 3, 7,                  //  8668:          check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8672:          check predicate 31
  OPC_Decode, 238, 10, 212, 1,               //  8674:          decode to MVE_VMLSDAVaxs8 using decoder 212
                                             //  8674:         } else try {
  OPC_CheckPredicate, 31,                    //  8679:          check predicate 31
  OPC_Decode, 151, 13, 213, 1,               //  8681:          decode to MVE_VRMLSLDAVHaxs32 using decoder 213
                                             //  8681:         }
                                             //  8681:        }
                                             //  8681:        } // switch Inst[31:28]
                                             //  8681:       }
  1, 0,                                      //  8686:       case 0x1: {
  OPC_CheckField, 28, 4, 14,                 //  8688:        check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //  8692:        try {
  OPC_CheckField, 20, 3, 7,                  //  8694:         check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8698:         check predicate 31
  OPC_Decode, 237, 10, 212, 1,               //  8700:         decode to MVE_VMLSDAVaxs32 using decoder 212
                                             //  8700:        } else try {
  OPC_CheckPredicate, 31,                    //  8705:         check predicate 31
  OPC_Decode, 248, 10, 213, 1,               //  8707:         decode to MVE_VMLSLDAVaxs32 using decoder 213
                                             //  8707:        }
                                             //  8707:       }
                                             //  8707:       } // switch Inst[16]
                                             //  8707:      }
                                             //  8707:      } // switch Inst[12]
                                             //  8707:     }
                                             //  8707:     } // switch Inst[7:4]
                                             //  8707:    }
                                             //  8707:    } // switch Inst[0]
                                             //  8707:   }
  15, 0,                                     //  8712:   case 0xf: {
  OPC_SwitchField, 6, 1,                     //  8714:    switch Inst[6] {
  0, 252, 6,                                 //  8717:    case 0x0: {
  OPC_SwitchField, 0, 1,                     //  8720:     switch Inst[0] {
  0, 252, 5,                                 //  8723:     case 0x0: {
  OPC_SwitchField, 4, 2,                     //  8726:      switch Inst[5:4] {
  0, 132, 4,                                 //  8729:      case 0x0: {
  OPC_SwitchField, 7, 1,                     //  8732:       switch Inst[7] {
  0, 223, 2,                                 //  8735:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  8738:        switch Inst[16] {
  0, 205, 1,                                 //  8741:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  8744:         switch Inst[31:28] {
  14, 124,                                   //  8747:         case 0xe: {
  OPC_Scope, 75,                             //  8749:          try {
  OPC_SwitchField, 17, 6,                    //  8751:           switch Inst[22:17] {
  48, 7,                                     //  8754:           case 0x30: {
  OPC_CheckPredicate, 31,                    //  8756:            check predicate 31
  OPC_Decode, 147, 10, 214, 1,               //  8758:            decode to MVE_VMAXAVs8 using decoder 214
                                             //  8758:           }
  49, 7,                                     //  8763:           case 0x31: {
  OPC_CheckPredicate, 31,                    //  8765:            check predicate 31
  OPC_Decode, 161, 10, 214, 1,               //  8767:            decode to MVE_VMAXVs8 using decoder 214
                                             //  8767:           }
  50, 7,                                     //  8772:           case 0x32: {
  OPC_CheckPredicate, 31,                    //  8774:            check predicate 31
  OPC_Decode, 145, 10, 214, 1,               //  8776:            decode to MVE_VMAXAVs16 using decoder 214
                                             //  8776:           }
  51, 7,                                     //  8781:           case 0x33: {
  OPC_CheckPredicate, 31,                    //  8783:            check predicate 31
  OPC_Decode, 159, 10, 214, 1,               //  8785:            decode to MVE_VMAXVs16 using decoder 214
                                             //  8785:           }
  52, 7,                                     //  8790:           case 0x34: {
  OPC_CheckPredicate, 31,                    //  8792:            check predicate 31
  OPC_Decode, 146, 10, 214, 1,               //  8794:            decode to MVE_VMAXAVs32 using decoder 214
                                             //  8794:           }
  53, 7,                                     //  8799:           case 0x35: {
  OPC_CheckPredicate, 31,                    //  8801:            check predicate 31
  OPC_Decode, 160, 10, 214, 1,               //  8803:            decode to MVE_VMAXVs32 using decoder 214
                                             //  8803:           }
  54, 7,                                     //  8808:           case 0x36: {
  OPC_CheckPredicate, 33,                    //  8810:            check predicate 33
  OPC_Decode, 152, 10, 214, 1,               //  8812:            decode to MVE_VMAXNMAVf32 using decoder 214
                                             //  8812:           }
  55, 0,                                     //  8817:           case 0x37: {
  OPC_CheckPredicate, 33,                    //  8819:            check predicate 33
  OPC_Decode, 156, 10, 214, 1,               //  8821:            decode to MVE_VMAXNMVf32 using decoder 214
                                             //  8821:           }
                                             //  8821:           } // switch Inst[22:17]
                                             //  8821:          } else try {
  OPC_SwitchField, 12, 1,                    //  8826:           switch Inst[12] {
  0, 20,                                     //  8829:           case 0x0: {
  OPC_Scope, 11,                             //  8831:            try {
  OPC_CheckField, 20, 3, 7,                  //  8833:             check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8837:             check predicate 31
  OPC_Decode, 208, 10, 210, 1,               //  8839:             decode to MVE_VMLADAVs8 using decoder 210
                                             //  8839:            } else try {
  OPC_CheckPredicate, 31,                    //  8844:             check predicate 31
  OPC_Decode, 147, 13, 211, 1,               //  8846:             decode to MVE_VRMLALDAVHs32 using decoder 211
                                             //  8846:            }
                                             //  8846:           }
  1, 0,                                      //  8851:           case 0x1: {
  OPC_Scope, 11,                             //  8853:            try {
  OPC_CheckField, 20, 3, 7,                  //  8855:             check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8859:             check predicate 31
  OPC_Decode, 214, 10, 210, 1,               //  8861:             decode to MVE_VMLADAVxs8 using decoder 210
                                             //  8861:            } else try {
  OPC_CheckPredicate, 31,                    //  8866:             check predicate 31
  OPC_Decode, 149, 13, 211, 1,               //  8868:             decode to MVE_VRMLALDAVHxs32 using decoder 211
                                             //  8868:            }
                                             //  8868:           }
                                             //  8868:           } // switch Inst[12]
                                             //  8868:          }
                                             //  8868:         }
  15, 0,                                     //  8873:         case 0xf: {
  OPC_Scope, 48,                             //  8875:          try {
  OPC_SwitchField, 17, 6,                    //  8877:           switch Inst[22:17] {
  49, 7,                                     //  8880:           case 0x31: {
  OPC_CheckPredicate, 31,                    //  8882:            check predicate 31
  OPC_Decode, 164, 10, 214, 1,               //  8884:            decode to MVE_VMAXVu8 using decoder 214
                                             //  8884:           }
  51, 7,                                     //  8889:           case 0x33: {
  OPC_CheckPredicate, 31,                    //  8891:            check predicate 31
  OPC_Decode, 162, 10, 214, 1,               //  8893:            decode to MVE_VMAXVu16 using decoder 214
                                             //  8893:           }
  53, 7,                                     //  8898:           case 0x35: {
  OPC_CheckPredicate, 31,                    //  8900:            check predicate 31
  OPC_Decode, 163, 10, 214, 1,               //  8902:            decode to MVE_VMAXVu32 using decoder 214
                                             //  8902:           }
  54, 7,                                     //  8907:           case 0x36: {
  OPC_CheckPredicate, 33,                    //  8909:            check predicate 33
  OPC_Decode, 151, 10, 214, 1,               //  8911:            decode to MVE_VMAXNMAVf16 using decoder 214
                                             //  8911:           }
  55, 0,                                     //  8916:           case 0x37: {
  OPC_CheckPredicate, 33,                    //  8918:            check predicate 33
  OPC_Decode, 155, 10, 214, 1,               //  8920:            decode to MVE_VMAXNMVf16 using decoder 214
                                             //  8920:           }
                                             //  8920:           } // switch Inst[22:17]
                                             //  8920:          } else try {
  OPC_CheckField, 12, 1, 0,                  //  8925:           check Inst[12] == 0x0
  OPC_Scope, 11,                             //  8929:           try {
  OPC_CheckField, 20, 3, 7,                  //  8931:            check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  8935:            check predicate 31
  OPC_Decode, 211, 10, 210, 1,               //  8937:            decode to MVE_VMLADAVu8 using decoder 210
                                             //  8937:           } else try {
  OPC_CheckPredicate, 31,                    //  8942:            check predicate 31
  OPC_Decode, 148, 13, 211, 1,               //  8944:            decode to MVE_VRMLALDAVHu32 using decoder 211
                                             //  8944:           }
                                             //  8944:          }
                                             //  8944:         }
                                             //  8944:         } // switch Inst[31:28]
                                             //  8944:        }
  1, 0,                                      //  8949:        case 0x1: {
  OPC_SwitchField, 17, 3,                    //  8951:         switch Inst[19:17] {
  0, 37,                                     //  8954:         case 0x0: {
  OPC_SwitchField, 28, 4,                    //  8956:          switch Inst[31:28] {
  14, 15,                                    //  8959:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  8961:           check predicate 31
  OPC_CheckField, 20, 3, 7,                  //  8963:           check Inst[22:20] == 0x7
  OPC_CheckField, 12, 1, 0,                  //  8967:           check Inst[12] == 0x0
  OPC_Decode, 167, 8, 215, 1,                //  8971:           decode to MVE_VADDVs8no_acc using decoder 215
                                             //  8971:          }
  15, 0,                                     //  8976:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  8978:           check predicate 31
  OPC_CheckField, 20, 3, 7,                  //  8980:           check Inst[22:20] == 0x7
  OPC_CheckField, 12, 1, 0,                  //  8984:           check Inst[12] == 0x0
  OPC_Decode, 173, 8, 215, 1,                //  8988:           decode to MVE_VADDVu8no_acc using decoder 215
                                             //  8988:          }
                                             //  8988:          } // switch Inst[31:28]
                                             //  8988:         }
  2, 37,                                     //  8993:         case 0x2: {
  OPC_SwitchField, 28, 4,                    //  8995:          switch Inst[31:28] {
  14, 15,                                    //  8998:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  9000:           check predicate 31
  OPC_CheckField, 20, 3, 7,                  //  9002:           check Inst[22:20] == 0x7
  OPC_CheckField, 12, 1, 0,                  //  9006:           check Inst[12] == 0x0
  OPC_Decode, 163, 8, 215, 1,                //  9010:           decode to MVE_VADDVs16no_acc using decoder 215
                                             //  9010:          }
  15, 0,                                     //  9015:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  9017:           check predicate 31
  OPC_CheckField, 20, 3, 7,                  //  9019:           check Inst[22:20] == 0x7
  OPC_CheckField, 12, 1, 0,                  //  9023:           check Inst[12] == 0x0
  OPC_Decode, 169, 8, 215, 1,                //  9027:           decode to MVE_VADDVu16no_acc using decoder 215
                                             //  9027:          }
                                             //  9027:          } // switch Inst[31:28]
                                             //  9027:         }
  4, 0,                                      //  9032:         case 0x4: {
  OPC_SwitchField, 28, 4,                    //  9034:          switch Inst[31:28] {
  14, 24,                                    //  9037:          case 0xe: {
  OPC_CheckField, 12, 1, 0,                  //  9039:           check Inst[12] == 0x0
  OPC_Scope, 11,                             //  9043:           try {
  OPC_CheckField, 20, 3, 7,                  //  9045:            check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  9049:            check predicate 31
  OPC_Decode, 165, 8, 215, 1,                //  9051:            decode to MVE_VADDVs32no_acc using decoder 215
                                             //  9051:           } else try {
  OPC_CheckPredicate, 31,                    //  9056:            check predicate 31
  OPC_Decode, 159, 8, 216, 1,                //  9058:            decode to MVE_VADDLVs32no_acc using decoder 216
                                             //  9058:           }
                                             //  9058:          }
  15, 0,                                     //  9063:          case 0xf: {
  OPC_CheckField, 12, 1, 0,                  //  9065:           check Inst[12] == 0x0
  OPC_Scope, 11,                             //  9069:           try {
  OPC_CheckField, 20, 3, 7,                  //  9071:            check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  9075:            check predicate 31
  OPC_Decode, 171, 8, 215, 1,                //  9077:            decode to MVE_VADDVu32no_acc using decoder 215
                                             //  9077:           } else try {
  OPC_CheckPredicate, 31,                    //  9082:            check predicate 31
  OPC_Decode, 161, 8, 216, 1,                //  9084:            decode to MVE_VADDLVu32no_acc using decoder 216
                                             //  9084:           }
                                             //  9084:          }
                                             //  9084:          } // switch Inst[31:28]
                                             //  9084:         }
                                             //  9084:         } // switch Inst[19:17]
                                             //  9084:        }
                                             //  9084:        } // switch Inst[16]
                                             //  9084:       }
  1, 0,                                      //  9089:       case 0x1: {
  OPC_SwitchField, 16, 7,                    //  9091:        switch Inst[22:16] {
  96, 11,                                    //  9094:        case 0x60: {
  OPC_CheckPredicate, 31,                    //  9096:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  9098:         check Inst[31:28] == 0xe
  OPC_Decode, 173, 10, 214, 1,               //  9102:         decode to MVE_VMINAVs8 using decoder 214
                                             //  9102:        }
  98, 21,                                    //  9107:        case 0x62: {
  OPC_SwitchField, 28, 4,                    //  9109:         switch Inst[31:28] {
  14, 7,                                     //  9112:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  9114:          check predicate 31
  OPC_Decode, 187, 10, 214, 1,               //  9116:          decode to MVE_VMINVs8 using decoder 214
                                             //  9116:         }
  15, 0,                                     //  9121:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  9123:          check predicate 31
  OPC_Decode, 190, 10, 214, 1,               //  9125:          decode to MVE_VMINVu8 using decoder 214
                                             //  9125:         }
                                             //  9125:         } // switch Inst[31:28]
                                             //  9125:        }
  100, 11,                                   //  9130:        case 0x64: {
  OPC_CheckPredicate, 31,                    //  9132:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  9134:         check Inst[31:28] == 0xe
  OPC_Decode, 171, 10, 214, 1,               //  9138:         decode to MVE_VMINAVs16 using decoder 214
                                             //  9138:        }
  102, 21,                                   //  9143:        case 0x66: {
  OPC_SwitchField, 28, 4,                    //  9145:         switch Inst[31:28] {
  14, 7,                                     //  9148:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  9150:          check predicate 31
  OPC_Decode, 185, 10, 214, 1,               //  9152:          decode to MVE_VMINVs16 using decoder 214
                                             //  9152:         }
  15, 0,                                     //  9157:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  9159:          check predicate 31
  OPC_Decode, 188, 10, 214, 1,               //  9161:          decode to MVE_VMINVu16 using decoder 214
                                             //  9161:         }
                                             //  9161:         } // switch Inst[31:28]
                                             //  9161:        }
  104, 11,                                   //  9166:        case 0x68: {
  OPC_CheckPredicate, 31,                    //  9168:         check predicate 31
  OPC_CheckField, 28, 4, 14,                 //  9170:         check Inst[31:28] == 0xe
  OPC_Decode, 172, 10, 214, 1,               //  9174:         decode to MVE_VMINAVs32 using decoder 214
                                             //  9174:        }
  106, 21,                                   //  9179:        case 0x6a: {
  OPC_SwitchField, 28, 4,                    //  9181:         switch Inst[31:28] {
  14, 7,                                     //  9184:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  9186:          check predicate 31
  OPC_Decode, 186, 10, 214, 1,               //  9188:          decode to MVE_VMINVs32 using decoder 214
                                             //  9188:         }
  15, 0,                                     //  9193:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  9195:          check predicate 31
  OPC_Decode, 189, 10, 214, 1,               //  9197:          decode to MVE_VMINVu32 using decoder 214
                                             //  9197:         }
                                             //  9197:         } // switch Inst[31:28]
                                             //  9197:        }
  108, 21,                                   //  9202:        case 0x6c: {
  OPC_SwitchField, 28, 4,                    //  9204:         switch Inst[31:28] {
  14, 7,                                     //  9207:         case 0xe: {
  OPC_CheckPredicate, 33,                    //  9209:          check predicate 33
  OPC_Decode, 178, 10, 214, 1,               //  9211:          decode to MVE_VMINNMAVf32 using decoder 214
                                             //  9211:         }
  15, 0,                                     //  9216:         case 0xf: {
  OPC_CheckPredicate, 33,                    //  9218:          check predicate 33
  OPC_Decode, 177, 10, 214, 1,               //  9220:          decode to MVE_VMINNMAVf16 using decoder 214
                                             //  9220:         }
                                             //  9220:         } // switch Inst[31:28]
                                             //  9220:        }
  110, 0,                                    //  9225:        case 0x6e: {
  OPC_SwitchField, 28, 4,                    //  9227:         switch Inst[31:28] {
  14, 7,                                     //  9230:         case 0xe: {
  OPC_CheckPredicate, 33,                    //  9232:          check predicate 33
  OPC_Decode, 182, 10, 214, 1,               //  9234:          decode to MVE_VMINNMVf32 using decoder 214
                                             //  9234:         }
  15, 0,                                     //  9239:         case 0xf: {
  OPC_CheckPredicate, 33,                    //  9241:          check predicate 33
  OPC_Decode, 181, 10, 214, 1,               //  9243:          decode to MVE_VMINNMVf16 using decoder 214
                                             //  9243:         }
                                             //  9243:         } // switch Inst[31:28]
                                             //  9243:        }
                                             //  9243:        } // switch Inst[22:16]
                                             //  9243:       }
                                             //  9243:       } // switch Inst[7]
                                             //  9243:      }
  2, 0,                                      //  9248:      case 0x2: {
  OPC_SwitchField, 12, 1,                    //  9250:       switch Inst[12] {
  0, 200, 1,                                 //  9253:       case 0x0: {
  OPC_SwitchField, 16, 1,                    //  9256:        switch Inst[16] {
  0, 55,                                     //  9259:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  9261:         switch Inst[31:28] {
  14, 24,                                    //  9264:         case 0xe: {
  OPC_CheckField, 7, 1, 0,                   //  9266:          check Inst[7] == 0x0
  OPC_Scope, 11,                             //  9270:          try {
  OPC_CheckField, 20, 3, 7,                  //  9272:           check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  9276:           check predicate 31
  OPC_Decode, 199, 10, 212, 1,               //  9278:           decode to MVE_VMLADAVas8 using decoder 212
                                             //  9278:          } else try {
  OPC_CheckPredicate, 31,                    //  9283:           check predicate 31
  OPC_Decode, 144, 13, 213, 1,               //  9285:           decode to MVE_VRMLALDAVHas32 using decoder 213
                                             //  9285:          }
                                             //  9285:         }
  15, 0,                                     //  9290:         case 0xf: {
  OPC_CheckField, 7, 1, 0,                   //  9292:          check Inst[7] == 0x0
  OPC_Scope, 11,                             //  9296:          try {
  OPC_CheckField, 20, 3, 7,                  //  9298:           check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  9302:           check predicate 31
  OPC_Decode, 202, 10, 212, 1,               //  9304:           decode to MVE_VMLADAVau8 using decoder 212
                                             //  9304:          } else try {
  OPC_CheckPredicate, 31,                    //  9309:           check predicate 31
  OPC_Decode, 145, 13, 213, 1,               //  9311:           decode to MVE_VRMLALDAVHau32 using decoder 213
                                             //  9311:          }
                                             //  9311:         }
                                             //  9311:         } // switch Inst[31:28]
                                             //  9311:        }
  1, 0,                                      //  9316:        case 0x1: {
  OPC_SwitchField, 17, 3,                    //  9318:         switch Inst[19:17] {
  0, 37,                                     //  9321:         case 0x0: {
  OPC_SwitchField, 28, 4,                    //  9323:          switch Inst[31:28] {
  14, 15,                                    //  9326:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  9328:           check predicate 31
  OPC_CheckField, 20, 3, 7,                  //  9330:           check Inst[22:20] == 0x7
  OPC_CheckField, 7, 1, 0,                   //  9334:           check Inst[7] == 0x0
  OPC_Decode, 166, 8, 217, 1,                //  9338:           decode to MVE_VADDVs8acc using decoder 217
                                             //  9338:          }
  15, 0,                                     //  9343:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  9345:           check predicate 31
  OPC_CheckField, 20, 3, 7,                  //  9347:           check Inst[22:20] == 0x7
  OPC_CheckField, 7, 1, 0,                   //  9351:           check Inst[7] == 0x0
  OPC_Decode, 172, 8, 217, 1,                //  9355:           decode to MVE_VADDVu8acc using decoder 217
                                             //  9355:          }
                                             //  9355:          } // switch Inst[31:28]
                                             //  9355:         }
  2, 37,                                     //  9360:         case 0x2: {
  OPC_SwitchField, 28, 4,                    //  9362:          switch Inst[31:28] {
  14, 15,                                    //  9365:          case 0xe: {
  OPC_CheckPredicate, 31,                    //  9367:           check predicate 31
  OPC_CheckField, 20, 3, 7,                  //  9369:           check Inst[22:20] == 0x7
  OPC_CheckField, 7, 1, 0,                   //  9373:           check Inst[7] == 0x0
  OPC_Decode, 162, 8, 217, 1,                //  9377:           decode to MVE_VADDVs16acc using decoder 217
                                             //  9377:          }
  15, 0,                                     //  9382:          case 0xf: {
  OPC_CheckPredicate, 31,                    //  9384:           check predicate 31
  OPC_CheckField, 20, 3, 7,                  //  9386:           check Inst[22:20] == 0x7
  OPC_CheckField, 7, 1, 0,                   //  9390:           check Inst[7] == 0x0
  OPC_Decode, 168, 8, 217, 1,                //  9394:           decode to MVE_VADDVu16acc using decoder 217
                                             //  9394:          }
                                             //  9394:          } // switch Inst[31:28]
                                             //  9394:         }
  4, 0,                                      //  9399:         case 0x4: {
  OPC_SwitchField, 28, 4,                    //  9401:          switch Inst[31:28] {
  14, 24,                                    //  9404:          case 0xe: {
  OPC_CheckField, 7, 1, 0,                   //  9406:           check Inst[7] == 0x0
  OPC_Scope, 11,                             //  9410:           try {
  OPC_CheckField, 20, 3, 7,                  //  9412:            check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  9416:            check predicate 31
  OPC_Decode, 164, 8, 217, 1,                //  9418:            decode to MVE_VADDVs32acc using decoder 217
                                             //  9418:           } else try {
  OPC_CheckPredicate, 31,                    //  9423:            check predicate 31
  OPC_Decode, 158, 8, 218, 1,                //  9425:            decode to MVE_VADDLVs32acc using decoder 218
                                             //  9425:           }
                                             //  9425:          }
  15, 0,                                     //  9430:          case 0xf: {
  OPC_CheckField, 7, 1, 0,                   //  9432:           check Inst[7] == 0x0
  OPC_Scope, 11,                             //  9436:           try {
  OPC_CheckField, 20, 3, 7,                  //  9438:            check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  9442:            check predicate 31
  OPC_Decode, 170, 8, 217, 1,                //  9444:            decode to MVE_VADDVu32acc using decoder 217
                                             //  9444:           } else try {
  OPC_CheckPredicate, 31,                    //  9449:            check predicate 31
  OPC_Decode, 160, 8, 218, 1,                //  9451:            decode to MVE_VADDLVu32acc using decoder 218
                                             //  9451:           }
                                             //  9451:          }
                                             //  9451:          } // switch Inst[31:28]
                                             //  9451:         }
                                             //  9451:         } // switch Inst[19:17]
                                             //  9451:        }
                                             //  9451:        } // switch Inst[16]
                                             //  9451:       }
  1, 0,                                      //  9456:       case 0x1: {
  OPC_CheckField, 7, 1, 0,                   //  9458:        check Inst[7] == 0x0
  OPC_CheckField, 16, 1, 0,                  //  9462:        check Inst[16] == 0x0
  OPC_CheckField, 28, 4, 14,                 //  9466:        check Inst[31:28] == 0xe
  OPC_Scope, 11,                             //  9470:        try {
  OPC_CheckField, 20, 3, 7,                  //  9472:         check Inst[22:20] == 0x7
  OPC_CheckPredicate, 31,                    //  9476:         check predicate 31
  OPC_Decode, 205, 10, 212, 1,               //  9478:         decode to MVE_VMLADAVaxs8 using decoder 212
                                             //  9478:        } else try {
  OPC_CheckPredicate, 31,                    //  9483:         check predicate 31
  OPC_Decode, 146, 13, 213, 1,               //  9485:         decode to MVE_VRMLALDAVHaxs32 using decoder 213
                                             //  9485:        }
                                             //  9485:       }
                                             //  9485:       } // switch Inst[12]
                                             //  9485:      }
                                             //  9485:      } // switch Inst[5:4]
                                             //  9485:     }
  1, 0,                                      //  9490:     case 0x1: {
  OPC_SwitchField, 20, 3,                    //  9492:      switch Inst[22:20] {
  0, 37,                                     //  9495:      case 0x0: {
  OPC_SwitchField, 28, 4,                    //  9497:       switch Inst[31:28] {
  14, 15,                                    //  9500:       case 0xe: {
  OPC_CheckPredicate, 31,                    //  9502:        check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  9504:        check Inst[16] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  9508:        check Inst[4] == 0x0
  OPC_Decode, 139, 8, 219, 1,                //  9512:        decode to MVE_VABAVs8 using decoder 219
                                             //  9512:       }
  15, 0,                                     //  9517:       case 0xf: {
  OPC_CheckPredicate, 31,                    //  9519:        check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  9521:        check Inst[16] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  9525:        check Inst[4] == 0x0
  OPC_Decode, 142, 8, 219, 1,                //  9529:        decode to MVE_VABAVu8 using decoder 219
                                             //  9529:       }
                                             //  9529:       } // switch Inst[31:28]
                                             //  9529:      }
  1, 37,                                     //  9534:      case 0x1: {
  OPC_SwitchField, 28, 4,                    //  9536:       switch Inst[31:28] {
  14, 15,                                    //  9539:       case 0xe: {
  OPC_CheckPredicate, 31,                    //  9541:        check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  9543:        check Inst[16] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  9547:        check Inst[4] == 0x0
  OPC_Decode, 137, 8, 219, 1,                //  9551:        decode to MVE_VABAVs16 using decoder 219
                                             //  9551:       }
  15, 0,                                     //  9556:       case 0xf: {
  OPC_CheckPredicate, 31,                    //  9558:        check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  9560:        check Inst[16] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  9564:        check Inst[4] == 0x0
  OPC_Decode, 140, 8, 219, 1,                //  9568:        decode to MVE_VABAVu16 using decoder 219
                                             //  9568:       }
                                             //  9568:       } // switch Inst[31:28]
                                             //  9568:      }
  2, 0,                                      //  9573:      case 0x2: {
  OPC_SwitchField, 28, 4,                    //  9575:       switch Inst[31:28] {
  14, 15,                                    //  9578:       case 0xe: {
  OPC_CheckPredicate, 31,                    //  9580:        check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  9582:        check Inst[16] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  9586:        check Inst[4] == 0x0
  OPC_Decode, 138, 8, 219, 1,                //  9590:        decode to MVE_VABAVs32 using decoder 219
                                             //  9590:       }
  15, 0,                                     //  9595:       case 0xf: {
  OPC_CheckPredicate, 31,                    //  9597:        check predicate 31
  OPC_CheckField, 16, 1, 0,                  //  9599:        check Inst[16] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  9603:        check Inst[4] == 0x0
  OPC_Decode, 141, 8, 219, 1,                //  9607:        decode to MVE_VABAVu32 using decoder 219
                                             //  9607:       }
                                             //  9607:       } // switch Inst[31:28]
                                             //  9607:      }
                                             //  9607:      } // switch Inst[22:20]
                                             //  9607:     }
                                             //  9607:     } // switch Inst[0]
                                             //  9607:    }
  1, 0,                                      //  9612:    case 0x1: {
  OPC_SwitchField, 7, 1,                     //  9614:     switch Inst[7] {
  0, 218, 4,                                 //  9617:     case 0x0: {
  OPC_SwitchField, 20, 2,                    //  9620:      switch Inst[21:20] {
  0, 169, 1,                                 //  9623:      case 0x0: {
  OPC_SwitchField, 0, 1,                     //  9626:       switch Inst[0] {
  0, 81,                                     //  9629:       case 0x0: {
  OPC_SwitchField, 12, 1,                    //  9631:        switch Inst[12] {
  0, 37,                                     //  9634:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  9636:         switch Inst[31:28] {
  14, 15,                                    //  9639:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  9641:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  //  9643:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  9647:          check Inst[4] == 0x0
  OPC_Decode, 224, 12, 220, 1,               //  9651:          decode to MVE_VQSHRNbhs16 using decoder 220
                                             //  9651:         }
  15, 0,                                     //  9656:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  9658:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  //  9660:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  9664:          check Inst[4] == 0x0
  OPC_Decode, 226, 12, 220, 1,               //  9668:          decode to MVE_VQSHRNbhu16 using decoder 220
                                             //  9668:         }
                                             //  9668:         } // switch Inst[31:28]
                                             //  9668:        }
  1, 0,                                      //  9673:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  9675:         switch Inst[31:28] {
  14, 15,                                    //  9678:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  9680:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  //  9682:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  9686:          check Inst[4] == 0x0
  OPC_Decode, 228, 12, 220, 1,               //  9690:          decode to MVE_VQSHRNths16 using decoder 220
                                             //  9690:         }
  15, 0,                                     //  9695:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  9697:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  //  9699:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  9703:          check Inst[4] == 0x0
  OPC_Decode, 230, 12, 220, 1,               //  9707:          decode to MVE_VQSHRNthu16 using decoder 220
                                             //  9707:         }
                                             //  9707:         } // switch Inst[31:28]
                                             //  9707:        }
                                             //  9707:        } // switch Inst[12]
                                             //  9707:       }
  1, 0,                                      //  9712:       case 0x1: {
  OPC_SwitchField, 12, 1,                    //  9714:        switch Inst[12] {
  0, 37,                                     //  9717:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  9719:         switch Inst[31:28] {
  14, 15,                                    //  9722:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  9724:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  //  9726:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  9730:          check Inst[4] == 0x0
  OPC_Decode, 191, 12, 220, 1,               //  9734:          decode to MVE_VQRSHRNbhs16 using decoder 220
                                             //  9734:         }
  15, 0,                                     //  9739:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  9741:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  //  9743:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  9747:          check Inst[4] == 0x0
  OPC_Decode, 193, 12, 220, 1,               //  9751:          decode to MVE_VQRSHRNbhu16 using decoder 220
                                             //  9751:         }
                                             //  9751:         } // switch Inst[31:28]
                                             //  9751:        }
  1, 0,                                      //  9756:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  9758:         switch Inst[31:28] {
  14, 15,                                    //  9761:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  9763:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  //  9765:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  9769:          check Inst[4] == 0x0
  OPC_Decode, 195, 12, 220, 1,               //  9773:          decode to MVE_VQRSHRNths16 using decoder 220
                                             //  9773:         }
  15, 0,                                     //  9778:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  9780:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  //  9782:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  9786:          check Inst[4] == 0x0
  OPC_Decode, 197, 12, 220, 1,               //  9790:          decode to MVE_VQRSHRNthu16 using decoder 220
                                             //  9790:         }
                                             //  9790:         } // switch Inst[31:28]
                                             //  9790:        }
                                             //  9790:        } // switch Inst[12]
                                             //  9790:       }
                                             //  9790:       } // switch Inst[0]
                                             //  9790:      }
  1, 137, 1,                                 //  9795:      case 0x1: {
  OPC_SwitchField, 0, 1,                     //  9798:       switch Inst[0] {
  0, 65,                                     //  9801:       case 0x0: {
  OPC_SwitchField, 12, 1,                    //  9803:        switch Inst[12] {
  0, 29,                                     //  9806:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  9808:         switch Inst[31:28] {
  14, 11,                                    //  9811:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  9813:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  9815:          check Inst[4] == 0x0
  OPC_Decode, 225, 12, 221, 1,               //  9819:          decode to MVE_VQSHRNbhs32 using decoder 221
                                             //  9819:         }
  15, 0,                                     //  9824:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  9826:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  9828:          check Inst[4] == 0x0
  OPC_Decode, 227, 12, 221, 1,               //  9832:          decode to MVE_VQSHRNbhu32 using decoder 221
                                             //  9832:         }
                                             //  9832:         } // switch Inst[31:28]
                                             //  9832:        }
  1, 0,                                      //  9837:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  9839:         switch Inst[31:28] {
  14, 11,                                    //  9842:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  9844:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  9846:          check Inst[4] == 0x0
  OPC_Decode, 229, 12, 221, 1,               //  9850:          decode to MVE_VQSHRNths32 using decoder 221
                                             //  9850:         }
  15, 0,                                     //  9855:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  9857:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  9859:          check Inst[4] == 0x0
  OPC_Decode, 231, 12, 221, 1,               //  9863:          decode to MVE_VQSHRNthu32 using decoder 221
                                             //  9863:         }
                                             //  9863:         } // switch Inst[31:28]
                                             //  9863:        }
                                             //  9863:        } // switch Inst[12]
                                             //  9863:       }
  1, 0,                                      //  9868:       case 0x1: {
  OPC_SwitchField, 12, 1,                    //  9870:        switch Inst[12] {
  0, 29,                                     //  9873:        case 0x0: {
  OPC_SwitchField, 28, 4,                    //  9875:         switch Inst[31:28] {
  14, 11,                                    //  9878:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  9880:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  9882:          check Inst[4] == 0x0
  OPC_Decode, 192, 12, 221, 1,               //  9886:          decode to MVE_VQRSHRNbhs32 using decoder 221
                                             //  9886:         }
  15, 0,                                     //  9891:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  9893:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  9895:          check Inst[4] == 0x0
  OPC_Decode, 194, 12, 221, 1,               //  9899:          decode to MVE_VQRSHRNbhu32 using decoder 221
                                             //  9899:         }
                                             //  9899:         } // switch Inst[31:28]
                                             //  9899:        }
  1, 0,                                      //  9904:        case 0x1: {
  OPC_SwitchField, 28, 4,                    //  9906:         switch Inst[31:28] {
  14, 11,                                    //  9909:         case 0xe: {
  OPC_CheckPredicate, 31,                    //  9911:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  9913:          check Inst[4] == 0x0
  OPC_Decode, 196, 12, 221, 1,               //  9917:          decode to MVE_VQRSHRNths32 using decoder 221
                                             //  9917:         }
  15, 0,                                     //  9922:         case 0xf: {
  OPC_CheckPredicate, 31,                    //  9924:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   //  9926:          check Inst[4] == 0x0
  OPC_Decode, 198, 12, 221, 1,               //  9930:          decode to MVE_VQRSHRNthu32 using decoder 221
                                             //  9930:         }
                                             //  9930:         } // switch Inst[31:28]
                                             //  9930:        }
                                             //  9930:        } // switch Inst[12]
                                             //  9930:       }
                                             //  9930:       } // switch Inst[0]
                                             //  9930:      }
  2, 149, 1,                                 //  9935:      case 0x2: {
  OPC_SwitchField, 12, 1,                    //  9938:       switch Inst[12] {
  0, 71,                                     //  9941:       case 0x0: {
  OPC_SwitchField, 28, 4,                    //  9943:        switch Inst[31:28] {
  14, 32,                                    //  9946:        case 0xe: {
  OPC_CheckField, 0, 1, 0,                   //  9948:         check Inst[0] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  9952:         check Inst[4] == 0x0
  OPC_CheckField, 19, 1, 1,                  //  9956:         check Inst[19] == 0x1
  OPC_Scope, 11,                             //  9960:         try {
  OPC_CheckField, 16, 3, 0,                  //  9962:          check Inst[18:16] == 0x0
  OPC_CheckPredicate, 31,                    //  9966:          check predicate 31
  OPC_Decode, 255, 10, 183, 1,               //  9968:          decode to MVE_VMOVLs8bh using decoder 183
                                             //  9968:         } else try {
  OPC_CheckPredicate, 31,                    //  9973:          check predicate 31
  OPC_Decode, 187, 13, 222, 1,               //  9975:          decode to MVE_VSHLL_imms8bh using decoder 222
                                             //  9975:         }
                                             //  9975:        }
  15, 0,                                     //  9980:        case 0xf: {
  OPC_CheckField, 0, 1, 0,                   //  9982:         check Inst[0] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  9986:         check Inst[4] == 0x0
  OPC_CheckField, 19, 1, 1,                  //  9990:         check Inst[19] == 0x1
  OPC_Scope, 11,                             //  9994:         try {
  OPC_CheckField, 16, 3, 0,                  //  9996:          check Inst[18:16] == 0x0
  OPC_CheckPredicate, 31,                    // 10000:          check predicate 31
  OPC_Decode, 131, 11, 183, 1,               // 10002:          decode to MVE_VMOVLu8bh using decoder 183
                                             // 10002:         } else try {
  OPC_CheckPredicate, 31,                    // 10007:          check predicate 31
  OPC_Decode, 191, 13, 222, 1,               // 10009:          decode to MVE_VSHLL_immu8bh using decoder 222
                                             // 10009:         }
                                             // 10009:        }
                                             // 10009:        } // switch Inst[31:28]
                                             // 10009:       }
  1, 0,                                      // 10014:       case 0x1: {
  OPC_SwitchField, 28, 4,                    // 10016:        switch Inst[31:28] {
  14, 32,                                    // 10019:        case 0xe: {
  OPC_CheckField, 0, 1, 0,                   // 10021:         check Inst[0] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 10025:         check Inst[4] == 0x0
  OPC_CheckField, 19, 1, 1,                  // 10029:         check Inst[19] == 0x1
  OPC_Scope, 11,                             // 10033:         try {
  OPC_CheckField, 16, 3, 0,                  // 10035:          check Inst[18:16] == 0x0
  OPC_CheckPredicate, 31,                    // 10039:          check predicate 31
  OPC_Decode, 128, 11, 183, 1,               // 10041:          decode to MVE_VMOVLs8th using decoder 183
                                             // 10041:         } else try {
  OPC_CheckPredicate, 31,                    // 10046:          check predicate 31
  OPC_Decode, 188, 13, 222, 1,               // 10048:          decode to MVE_VSHLL_imms8th using decoder 222
                                             // 10048:         }
                                             // 10048:        }
  15, 0,                                     // 10053:        case 0xf: {
  OPC_CheckField, 0, 1, 0,                   // 10055:         check Inst[0] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 10059:         check Inst[4] == 0x0
  OPC_CheckField, 19, 1, 1,                  // 10063:         check Inst[19] == 0x1
  OPC_Scope, 11,                             // 10067:         try {
  OPC_CheckField, 16, 3, 0,                  // 10069:          check Inst[18:16] == 0x0
  OPC_CheckPredicate, 31,                    // 10073:          check predicate 31
  OPC_Decode, 132, 11, 183, 1,               // 10075:          decode to MVE_VMOVLu8th using decoder 183
                                             // 10075:         } else try {
  OPC_CheckPredicate, 31,                    // 10080:          check predicate 31
  OPC_Decode, 192, 13, 222, 1,               // 10082:          decode to MVE_VSHLL_immu8th using decoder 222
                                             // 10082:         }
                                             // 10082:        }
                                             // 10082:        } // switch Inst[31:28]
                                             // 10082:       }
                                             // 10082:       } // switch Inst[12]
                                             // 10082:      }
  3, 0,                                      // 10087:      case 0x3: {
  OPC_SwitchField, 12, 1,                    // 10089:       switch Inst[12] {
  0, 63,                                     // 10092:       case 0x0: {
  OPC_SwitchField, 28, 4,                    // 10094:        switch Inst[31:28] {
  14, 28,                                    // 10097:        case 0xe: {
  OPC_CheckField, 0, 1, 0,                   // 10099:         check Inst[0] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 10103:         check Inst[4] == 0x0
  OPC_Scope, 11,                             // 10107:         try {
  OPC_CheckField, 16, 4, 0,                  // 10109:          check Inst[19:16] == 0x0
  OPC_CheckPredicate, 31,                    // 10113:          check predicate 31
  OPC_Decode, 253, 10, 183, 1,               // 10115:          decode to MVE_VMOVLs16bh using decoder 183
                                             // 10115:         } else try {
  OPC_CheckPredicate, 31,                    // 10120:          check predicate 31
  OPC_Decode, 185, 13, 223, 1,               // 10122:          decode to MVE_VSHLL_imms16bh using decoder 223
                                             // 10122:         }
                                             // 10122:        }
  15, 0,                                     // 10127:        case 0xf: {
  OPC_CheckField, 0, 1, 0,                   // 10129:         check Inst[0] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 10133:         check Inst[4] == 0x0
  OPC_Scope, 11,                             // 10137:         try {
  OPC_CheckField, 16, 4, 0,                  // 10139:          check Inst[19:16] == 0x0
  OPC_CheckPredicate, 31,                    // 10143:          check predicate 31
  OPC_Decode, 129, 11, 183, 1,               // 10145:          decode to MVE_VMOVLu16bh using decoder 183
                                             // 10145:         } else try {
  OPC_CheckPredicate, 31,                    // 10150:          check predicate 31
  OPC_Decode, 189, 13, 223, 1,               // 10152:          decode to MVE_VSHLL_immu16bh using decoder 223
                                             // 10152:         }
                                             // 10152:        }
                                             // 10152:        } // switch Inst[31:28]
                                             // 10152:       }
  1, 0,                                      // 10157:       case 0x1: {
  OPC_SwitchField, 28, 4,                    // 10159:        switch Inst[31:28] {
  14, 28,                                    // 10162:        case 0xe: {
  OPC_CheckField, 0, 1, 0,                   // 10164:         check Inst[0] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 10168:         check Inst[4] == 0x0
  OPC_Scope, 11,                             // 10172:         try {
  OPC_CheckField, 16, 4, 0,                  // 10174:          check Inst[19:16] == 0x0
  OPC_CheckPredicate, 31,                    // 10178:          check predicate 31
  OPC_Decode, 254, 10, 183, 1,               // 10180:          decode to MVE_VMOVLs16th using decoder 183
                                             // 10180:         } else try {
  OPC_CheckPredicate, 31,                    // 10185:          check predicate 31
  OPC_Decode, 186, 13, 223, 1,               // 10187:          decode to MVE_VSHLL_imms16th using decoder 223
                                             // 10187:         }
                                             // 10187:        }
  15, 0,                                     // 10192:        case 0xf: {
  OPC_CheckField, 0, 1, 0,                   // 10194:         check Inst[0] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 10198:         check Inst[4] == 0x0
  OPC_Scope, 11,                             // 10202:         try {
  OPC_CheckField, 16, 4, 0,                  // 10204:          check Inst[19:16] == 0x0
  OPC_CheckPredicate, 31,                    // 10208:          check predicate 31
  OPC_Decode, 130, 11, 183, 1,               // 10210:          decode to MVE_VMOVLu16th using decoder 183
                                             // 10210:         } else try {
  OPC_CheckPredicate, 31,                    // 10215:          check predicate 31
  OPC_Decode, 190, 13, 223, 1,               // 10217:          decode to MVE_VSHLL_immu16th using decoder 223
                                             // 10217:         }
                                             // 10217:        }
                                             // 10217:        } // switch Inst[31:28]
                                             // 10217:       }
                                             // 10217:       } // switch Inst[12]
                                             // 10217:      }
                                             // 10217:      } // switch Inst[21:20]
                                             // 10217:     }
  1, 0,                                      // 10222:     case 0x1: {
  OPC_SwitchField, 12, 1,                    // 10224:      switch Inst[12] {
  0, 176, 1,                                 // 10227:      case 0x0: {
  OPC_SwitchField, 21, 1,                    // 10230:       switch Inst[21] {
  0, 153, 1,                                 // 10233:       case 0x0: {
  OPC_SwitchField, 0, 1,                     // 10236:        switch Inst[0] {
  0, 73,                                     // 10239:        case 0x0: {
  OPC_SwitchField, 20, 1,                    // 10241:         switch Inst[20] {
  0, 37,                                     // 10244:         case 0x0: {
  OPC_SwitchField, 28, 4,                    // 10246:          switch Inst[31:28] {
  14, 15,                                    // 10249:          case 0xe: {
  OPC_CheckPredicate, 31,                    // 10251:           check predicate 31
  OPC_CheckField, 19, 1, 1,                  // 10253:           check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 10257:           check Inst[4] == 0x0
  OPC_Decode, 232, 12, 220, 1,               // 10261:           decode to MVE_VQSHRUNs16bh using decoder 220
                                             // 10261:          }
  15, 0,                                     // 10266:          case 0xf: {
  OPC_CheckPredicate, 31,                    // 10268:           check predicate 31
  OPC_CheckField, 19, 1, 1,                  // 10270:           check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 10274:           check Inst[4] == 0x0
  OPC_Decode, 199, 12, 220, 1,               // 10278:           decode to MVE_VQRSHRUNs16bh using decoder 220
                                             // 10278:          }
                                             // 10278:          } // switch Inst[31:28]
                                             // 10278:         }
  1, 0,                                      // 10283:         case 0x1: {
  OPC_SwitchField, 28, 4,                    // 10285:          switch Inst[31:28] {
  14, 11,                                    // 10288:          case 0xe: {
  OPC_CheckPredicate, 31,                    // 10290:           check predicate 31
  OPC_CheckField, 4, 1, 0,                   // 10292:           check Inst[4] == 0x0
  OPC_Decode, 234, 12, 221, 1,               // 10296:           decode to MVE_VQSHRUNs32bh using decoder 221
                                             // 10296:          }
  15, 0,                                     // 10301:          case 0xf: {
  OPC_CheckPredicate, 31,                    // 10303:           check predicate 31
  OPC_CheckField, 4, 1, 0,                   // 10305:           check Inst[4] == 0x0
  OPC_Decode, 201, 12, 221, 1,               // 10309:           decode to MVE_VQRSHRUNs32bh using decoder 221
                                             // 10309:          }
                                             // 10309:          } // switch Inst[31:28]
                                             // 10309:         }
                                             // 10309:         } // switch Inst[20]
                                             // 10309:        }
  1, 0,                                      // 10314:        case 0x1: {
  OPC_SwitchField, 20, 1,                    // 10316:         switch Inst[20] {
  0, 37,                                     // 10319:         case 0x0: {
  OPC_SwitchField, 28, 4,                    // 10321:          switch Inst[31:28] {
  14, 15,                                    // 10324:          case 0xe: {
  OPC_CheckPredicate, 31,                    // 10326:           check predicate 31
  OPC_CheckField, 19, 1, 1,                  // 10328:           check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 10332:           check Inst[4] == 0x0
  OPC_Decode, 216, 13, 220, 1,               // 10336:           decode to MVE_VSHRNi16bh using decoder 220
                                             // 10336:          }
  15, 0,                                     // 10341:          case 0xf: {
  OPC_CheckPredicate, 31,                    // 10343:           check predicate 31
  OPC_CheckField, 19, 1, 1,                  // 10345:           check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 10349:           check Inst[4] == 0x0
  OPC_Decode, 172, 13, 220, 1,               // 10353:           decode to MVE_VRSHRNi16bh using decoder 220
                                             // 10353:          }
                                             // 10353:          } // switch Inst[31:28]
                                             // 10353:         }
  1, 0,                                      // 10358:         case 0x1: {
  OPC_SwitchField, 28, 4,                    // 10360:          switch Inst[31:28] {
  14, 11,                                    // 10363:          case 0xe: {
  OPC_CheckPredicate, 31,                    // 10365:           check predicate 31
  OPC_CheckField, 4, 1, 0,                   // 10367:           check Inst[4] == 0x0
  OPC_Decode, 218, 13, 221, 1,               // 10371:           decode to MVE_VSHRNi32bh using decoder 221
                                             // 10371:          }
  15, 0,                                     // 10376:          case 0xf: {
  OPC_CheckPredicate, 31,                    // 10378:           check predicate 31
  OPC_CheckField, 4, 1, 0,                   // 10380:           check Inst[4] == 0x0
  OPC_Decode, 174, 13, 221, 1,               // 10384:           decode to MVE_VRSHRNi32bh using decoder 221
                                             // 10384:          }
                                             // 10384:          } // switch Inst[31:28]
                                             // 10384:         }
                                             // 10384:         } // switch Inst[20]
                                             // 10384:        }
                                             // 10384:        } // switch Inst[0]
                                             // 10384:       }
  1, 0,                                      // 10389:       case 0x1: {
  OPC_CheckPredicate, 31,                    // 10391:        check predicate 31
  OPC_CheckField, 28, 4, 14,                 // 10393:        check Inst[31:28] == 0xe
  OPC_CheckField, 4, 2, 0,                   // 10397:        check Inst[5:4] == 0x0
  OPC_Decode, 184, 13, 224, 1,               // 10401:        decode to MVE_VSHLC using decoder 224
                                             // 10401:       }
                                             // 10401:       } // switch Inst[21]
                                             // 10401:      }
  1, 0,                                      // 10406:      case 0x1: {
  OPC_SwitchField, 0, 1,                     // 10408:       switch Inst[0] {
  0, 73,                                     // 10411:       case 0x0: {
  OPC_SwitchField, 20, 2,                    // 10413:        switch Inst[21:20] {
  0, 37,                                     // 10416:        case 0x0: {
  OPC_SwitchField, 28, 4,                    // 10418:         switch Inst[31:28] {
  14, 15,                                    // 10421:         case 0xe: {
  OPC_CheckPredicate, 31,                    // 10423:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  // 10425:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 10429:          check Inst[4] == 0x0
  OPC_Decode, 233, 12, 220, 1,               // 10433:          decode to MVE_VQSHRUNs16th using decoder 220
                                             // 10433:         }
  15, 0,                                     // 10438:         case 0xf: {
  OPC_CheckPredicate, 31,                    // 10440:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  // 10442:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 10446:          check Inst[4] == 0x0
  OPC_Decode, 200, 12, 220, 1,               // 10450:          decode to MVE_VQRSHRUNs16th using decoder 220
                                             // 10450:         }
                                             // 10450:         } // switch Inst[31:28]
                                             // 10450:        }
  1, 0,                                      // 10455:        case 0x1: {
  OPC_SwitchField, 28, 4,                    // 10457:         switch Inst[31:28] {
  14, 11,                                    // 10460:         case 0xe: {
  OPC_CheckPredicate, 31,                    // 10462:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   // 10464:          check Inst[4] == 0x0
  OPC_Decode, 235, 12, 221, 1,               // 10468:          decode to MVE_VQSHRUNs32th using decoder 221
                                             // 10468:         }
  15, 0,                                     // 10473:         case 0xf: {
  OPC_CheckPredicate, 31,                    // 10475:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   // 10477:          check Inst[4] == 0x0
  OPC_Decode, 202, 12, 221, 1,               // 10481:          decode to MVE_VQRSHRUNs32th using decoder 221
                                             // 10481:         }
                                             // 10481:         } // switch Inst[31:28]
                                             // 10481:        }
                                             // 10481:        } // switch Inst[21:20]
                                             // 10481:       }
  1, 0,                                      // 10486:       case 0x1: {
  OPC_SwitchField, 20, 2,                    // 10488:        switch Inst[21:20] {
  0, 37,                                     // 10491:        case 0x0: {
  OPC_SwitchField, 28, 4,                    // 10493:         switch Inst[31:28] {
  14, 15,                                    // 10496:         case 0xe: {
  OPC_CheckPredicate, 31,                    // 10498:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  // 10500:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 10504:          check Inst[4] == 0x0
  OPC_Decode, 217, 13, 220, 1,               // 10508:          decode to MVE_VSHRNi16th using decoder 220
                                             // 10508:         }
  15, 0,                                     // 10513:         case 0xf: {
  OPC_CheckPredicate, 31,                    // 10515:          check predicate 31
  OPC_CheckField, 19, 1, 1,                  // 10517:          check Inst[19] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 10521:          check Inst[4] == 0x0
  OPC_Decode, 173, 13, 220, 1,               // 10525:          decode to MVE_VRSHRNi16th using decoder 220
                                             // 10525:         }
                                             // 10525:         } // switch Inst[31:28]
                                             // 10525:        }
  1, 0,                                      // 10530:        case 0x1: {
  OPC_SwitchField, 28, 4,                    // 10532:         switch Inst[31:28] {
  14, 11,                                    // 10535:         case 0xe: {
  OPC_CheckPredicate, 31,                    // 10537:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   // 10539:          check Inst[4] == 0x0
  OPC_Decode, 219, 13, 221, 1,               // 10543:          decode to MVE_VSHRNi32th using decoder 221
                                             // 10543:         }
  15, 0,                                     // 10548:         case 0xf: {
  OPC_CheckPredicate, 31,                    // 10550:          check predicate 31
  OPC_CheckField, 4, 1, 0,                   // 10552:          check Inst[4] == 0x0
  OPC_Decode, 175, 13, 221, 1,               // 10556:          decode to MVE_VRSHRNi32th using decoder 221
                                             // 10556:         }
                                             // 10556:         } // switch Inst[31:28]
                                             // 10556:        }
                                             // 10556:        } // switch Inst[21:20]
                                             // 10556:       }
                                             // 10556:       } // switch Inst[0]
                                             // 10556:      }
                                             // 10556:      } // switch Inst[12]
                                             // 10556:     }
                                             // 10556:     } // switch Inst[7]
                                             // 10556:    }
                                             // 10556:    } // switch Inst[6]
                                             // 10556:   }
                                             // 10556:   } // switch Inst[11:8]
                                             // 10556:  }
  2, 191, 22,                                // 10561:  case 0x2: {
  OPC_SwitchField, 8, 5,                     // 10564:   switch Inst[12:8] {
  0, 172, 2,                                 // 10567:   case 0x0: {
  OPC_SwitchField, 20, 2,                    // 10570:    switch Inst[21:20] {
  0, 97,                                     // 10573:    case 0x0: {
  OPC_SwitchField, 4, 1,                     // 10575:     switch Inst[4] {
  0, 45,                                     // 10578:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 10580:      switch Inst[31:28] {
  14, 19,                                    // 10583:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 10585:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10587:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10591:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10595:       check Inst[0] == 0x0
  OPC_Decode, 166, 9, 179, 1,                // 10599:       decode to MVE_VHADDs8 using decoder 179
                                             // 10599:      }
  15, 0,                                     // 10604:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 10606:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10608:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10612:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10616:       check Inst[0] == 0x0
  OPC_Decode, 169, 9, 179, 1,                // 10620:       decode to MVE_VHADDu8 using decoder 179
                                             // 10620:      }
                                             // 10620:      } // switch Inst[31:28]
                                             // 10620:     }
  1, 0,                                      // 10625:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 10627:      switch Inst[31:28] {
  14, 19,                                    // 10630:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 10632:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10634:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10638:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10642:       check Inst[0] == 0x0
  OPC_Decode, 232, 11, 179, 1,               // 10646:       decode to MVE_VQADDs8 using decoder 179
                                             // 10646:      }
  15, 0,                                     // 10651:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 10653:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10655:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10659:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10663:       check Inst[0] == 0x0
  OPC_Decode, 235, 11, 179, 1,               // 10667:       decode to MVE_VQADDu8 using decoder 179
                                             // 10667:      }
                                             // 10667:      } // switch Inst[31:28]
                                             // 10667:     }
                                             // 10667:     } // switch Inst[4]
                                             // 10667:    }
  1, 97,                                     // 10672:    case 0x1: {
  OPC_SwitchField, 4, 1,                     // 10674:     switch Inst[4] {
  0, 45,                                     // 10677:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 10679:      switch Inst[31:28] {
  14, 19,                                    // 10682:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 10684:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10686:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10690:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10694:       check Inst[0] == 0x0
  OPC_Decode, 164, 9, 179, 1,                // 10698:       decode to MVE_VHADDs16 using decoder 179
                                             // 10698:      }
  15, 0,                                     // 10703:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 10705:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10707:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10711:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10715:       check Inst[0] == 0x0
  OPC_Decode, 167, 9, 179, 1,                // 10719:       decode to MVE_VHADDu16 using decoder 179
                                             // 10719:      }
                                             // 10719:      } // switch Inst[31:28]
                                             // 10719:     }
  1, 0,                                      // 10724:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 10726:      switch Inst[31:28] {
  14, 19,                                    // 10729:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 10731:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10733:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10737:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10741:       check Inst[0] == 0x0
  OPC_Decode, 230, 11, 179, 1,               // 10745:       decode to MVE_VQADDs16 using decoder 179
                                             // 10745:      }
  15, 0,                                     // 10750:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 10752:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10754:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10758:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10762:       check Inst[0] == 0x0
  OPC_Decode, 233, 11, 179, 1,               // 10766:       decode to MVE_VQADDu16 using decoder 179
                                             // 10766:      }
                                             // 10766:      } // switch Inst[31:28]
                                             // 10766:     }
                                             // 10766:     } // switch Inst[4]
                                             // 10766:    }
  2, 0,                                      // 10771:    case 0x2: {
  OPC_SwitchField, 4, 1,                     // 10773:     switch Inst[4] {
  0, 45,                                     // 10776:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 10778:      switch Inst[31:28] {
  14, 19,                                    // 10781:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 10783:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10785:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10789:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10793:       check Inst[0] == 0x0
  OPC_Decode, 165, 9, 179, 1,                // 10797:       decode to MVE_VHADDs32 using decoder 179
                                             // 10797:      }
  15, 0,                                     // 10802:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 10804:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10806:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10810:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10814:       check Inst[0] == 0x0
  OPC_Decode, 168, 9, 179, 1,                // 10818:       decode to MVE_VHADDu32 using decoder 179
                                             // 10818:      }
                                             // 10818:      } // switch Inst[31:28]
                                             // 10818:     }
  1, 0,                                      // 10823:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 10825:      switch Inst[31:28] {
  14, 19,                                    // 10828:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 10830:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10832:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10836:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10840:       check Inst[0] == 0x0
  OPC_Decode, 231, 11, 179, 1,               // 10844:       decode to MVE_VQADDs32 using decoder 179
                                             // 10844:      }
  15, 0,                                     // 10849:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 10851:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10853:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10857:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10861:       check Inst[0] == 0x0
  OPC_Decode, 234, 11, 179, 1,               // 10865:       decode to MVE_VQADDu32 using decoder 179
                                             // 10865:      }
                                             // 10865:      } // switch Inst[31:28]
                                             // 10865:     }
                                             // 10865:     } // switch Inst[4]
                                             // 10865:    }
                                             // 10865:    } // switch Inst[21:20]
                                             // 10865:   }
  1, 157, 2,                                 // 10870:   case 0x1: {
  OPC_SwitchField, 20, 2,                    // 10873:    switch Inst[21:20] {
  0, 97,                                     // 10876:    case 0x0: {
  OPC_SwitchField, 4, 1,                     // 10878:     switch Inst[4] {
  0, 45,                                     // 10881:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 10883:      switch Inst[31:28] {
  14, 19,                                    // 10886:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 10888:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10890:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10894:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10898:       check Inst[0] == 0x0
  OPC_Decode, 128, 13, 179, 1,               // 10902:       decode to MVE_VRHADDs8 using decoder 179
                                             // 10902:      }
  15, 0,                                     // 10907:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 10909:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10911:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10915:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10919:       check Inst[0] == 0x0
  OPC_Decode, 131, 13, 179, 1,               // 10923:       decode to MVE_VRHADDu8 using decoder 179
                                             // 10923:      }
                                             // 10923:      } // switch Inst[31:28]
                                             // 10923:     }
  1, 0,                                      // 10928:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 10930:      switch Inst[31:28] {
  14, 19,                                    // 10933:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 10935:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10937:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10941:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10945:       check Inst[0] == 0x0
  OPC_Decode, 184, 8, 179, 1,                // 10949:       decode to MVE_VAND using decoder 179
                                             // 10949:      }
  15, 0,                                     // 10954:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 10956:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10958:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10962:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10966:       check Inst[0] == 0x0
  OPC_Decode, 149, 9, 179, 1,                // 10970:       decode to MVE_VEOR using decoder 179
                                             // 10970:      }
                                             // 10970:      } // switch Inst[31:28]
                                             // 10970:     }
                                             // 10970:     } // switch Inst[4]
                                             // 10970:    }
  1, 75,                                     // 10975:    case 0x1: {
  OPC_SwitchField, 4, 1,                     // 10977:     switch Inst[4] {
  0, 45,                                     // 10980:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 10982:      switch Inst[31:28] {
  14, 19,                                    // 10985:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 10987:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 10989:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 10993:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 10997:       check Inst[0] == 0x0
  OPC_Decode, 254, 12, 179, 1,               // 11001:       decode to MVE_VRHADDs16 using decoder 179
                                             // 11001:      }
  15, 0,                                     // 11006:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11008:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11010:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11014:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11018:       check Inst[0] == 0x0
  OPC_Decode, 129, 13, 179, 1,               // 11022:       decode to MVE_VRHADDu16 using decoder 179
                                             // 11022:      }
                                             // 11022:      } // switch Inst[31:28]
                                             // 11022:     }
  1, 0,                                      // 11027:     case 0x1: {
  OPC_CheckPredicate, 31,                    // 11029:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 // 11031:      check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 11035:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11039:      check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11043:      check Inst[0] == 0x0
  OPC_Decode, 185, 8, 179, 1,                // 11047:      decode to MVE_VBIC using decoder 179
                                             // 11047:     }
                                             // 11047:     } // switch Inst[4]
                                             // 11047:    }
  2, 75,                                     // 11052:    case 0x2: {
  OPC_SwitchField, 4, 1,                     // 11054:     switch Inst[4] {
  0, 45,                                     // 11057:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 11059:      switch Inst[31:28] {
  14, 19,                                    // 11062:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11064:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11066:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11070:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11074:       check Inst[0] == 0x0
  OPC_Decode, 255, 12, 179, 1,               // 11078:       decode to MVE_VRHADDs32 using decoder 179
                                             // 11078:      }
  15, 0,                                     // 11083:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11085:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11087:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11091:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11095:       check Inst[0] == 0x0
  OPC_Decode, 130, 13, 179, 1,               // 11099:       decode to MVE_VRHADDu32 using decoder 179
                                             // 11099:      }
                                             // 11099:      } // switch Inst[31:28]
                                             // 11099:     }
  1, 0,                                      // 11104:     case 0x1: {
  OPC_CheckPredicate, 31,                    // 11106:      check predicate 31
  OPC_CheckField, 28, 4, 14,                 // 11108:      check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 11112:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11116:      check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11120:      check Inst[0] == 0x0
  OPC_Decode, 193, 11, 179, 1,               // 11124:      decode to MVE_VORR using decoder 179
                                             // 11124:     }
                                             // 11124:     } // switch Inst[4]
                                             // 11124:    }
  3, 0,                                      // 11129:    case 0x3: {
  OPC_CheckPredicate, 31,                    // 11131:     check predicate 31
  OPC_CheckField, 28, 4, 14,                 // 11133:     check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 11137:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11141:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 11145:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11149:     check Inst[0] == 0x0
  OPC_Decode, 192, 11, 179, 1,               // 11153:     decode to MVE_VORN using decoder 179
                                             // 11153:    }
                                             // 11153:    } // switch Inst[21:20]
                                             // 11153:   }
  2, 172, 2,                                 // 11158:   case 0x2: {
  OPC_SwitchField, 20, 2,                    // 11161:    switch Inst[21:20] {
  0, 97,                                     // 11164:    case 0x0: {
  OPC_SwitchField, 4, 1,                     // 11166:     switch Inst[4] {
  0, 45,                                     // 11169:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 11171:      switch Inst[31:28] {
  14, 19,                                    // 11174:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11176:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11178:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11182:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11186:       check Inst[0] == 0x0
  OPC_Decode, 181, 9, 179, 1,                // 11190:       decode to MVE_VHSUBs8 using decoder 179
                                             // 11190:      }
  15, 0,                                     // 11195:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11197:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11199:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11203:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11207:       check Inst[0] == 0x0
  OPC_Decode, 184, 9, 179, 1,                // 11211:       decode to MVE_VHSUBu8 using decoder 179
                                             // 11211:      }
                                             // 11211:      } // switch Inst[31:28]
                                             // 11211:     }
  1, 0,                                      // 11216:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 11218:      switch Inst[31:28] {
  14, 19,                                    // 11221:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11223:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11225:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11229:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11233:       check Inst[0] == 0x0
  OPC_Decode, 244, 12, 179, 1,               // 11237:       decode to MVE_VQSUBs8 using decoder 179
                                             // 11237:      }
  15, 0,                                     // 11242:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11244:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11246:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11250:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11254:       check Inst[0] == 0x0
  OPC_Decode, 247, 12, 179, 1,               // 11258:       decode to MVE_VQSUBu8 using decoder 179
                                             // 11258:      }
                                             // 11258:      } // switch Inst[31:28]
                                             // 11258:     }
                                             // 11258:     } // switch Inst[4]
                                             // 11258:    }
  1, 97,                                     // 11263:    case 0x1: {
  OPC_SwitchField, 4, 1,                     // 11265:     switch Inst[4] {
  0, 45,                                     // 11268:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 11270:      switch Inst[31:28] {
  14, 19,                                    // 11273:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11275:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11277:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11281:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11285:       check Inst[0] == 0x0
  OPC_Decode, 179, 9, 179, 1,                // 11289:       decode to MVE_VHSUBs16 using decoder 179
                                             // 11289:      }
  15, 0,                                     // 11294:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11296:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11298:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11302:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11306:       check Inst[0] == 0x0
  OPC_Decode, 182, 9, 179, 1,                // 11310:       decode to MVE_VHSUBu16 using decoder 179
                                             // 11310:      }
                                             // 11310:      } // switch Inst[31:28]
                                             // 11310:     }
  1, 0,                                      // 11315:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 11317:      switch Inst[31:28] {
  14, 19,                                    // 11320:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11322:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11324:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11328:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11332:       check Inst[0] == 0x0
  OPC_Decode, 242, 12, 179, 1,               // 11336:       decode to MVE_VQSUBs16 using decoder 179
                                             // 11336:      }
  15, 0,                                     // 11341:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11343:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11345:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11349:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11353:       check Inst[0] == 0x0
  OPC_Decode, 245, 12, 179, 1,               // 11357:       decode to MVE_VQSUBu16 using decoder 179
                                             // 11357:      }
                                             // 11357:      } // switch Inst[31:28]
                                             // 11357:     }
                                             // 11357:     } // switch Inst[4]
                                             // 11357:    }
  2, 0,                                      // 11362:    case 0x2: {
  OPC_SwitchField, 4, 1,                     // 11364:     switch Inst[4] {
  0, 45,                                     // 11367:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 11369:      switch Inst[31:28] {
  14, 19,                                    // 11372:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11374:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11376:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11380:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11384:       check Inst[0] == 0x0
  OPC_Decode, 180, 9, 179, 1,                // 11388:       decode to MVE_VHSUBs32 using decoder 179
                                             // 11388:      }
  15, 0,                                     // 11393:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11395:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11397:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11401:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11405:       check Inst[0] == 0x0
  OPC_Decode, 183, 9, 179, 1,                // 11409:       decode to MVE_VHSUBu32 using decoder 179
                                             // 11409:      }
                                             // 11409:      } // switch Inst[31:28]
                                             // 11409:     }
  1, 0,                                      // 11414:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 11416:      switch Inst[31:28] {
  14, 19,                                    // 11419:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11421:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11423:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11427:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11431:       check Inst[0] == 0x0
  OPC_Decode, 243, 12, 179, 1,               // 11435:       decode to MVE_VQSUBs32 using decoder 179
                                             // 11435:      }
  15, 0,                                     // 11440:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11442:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11444:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11448:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11452:       check Inst[0] == 0x0
  OPC_Decode, 246, 12, 179, 1,               // 11456:       decode to MVE_VQSUBu32 using decoder 179
                                             // 11456:      }
                                             // 11456:      } // switch Inst[31:28]
                                             // 11456:     }
                                             // 11456:     } // switch Inst[4]
                                             // 11456:    }
                                             // 11456:    } // switch Inst[21:20]
                                             // 11456:   }
  4, 172, 2,                                 // 11461:   case 0x4: {
  OPC_SwitchField, 20, 2,                    // 11464:    switch Inst[21:20] {
  0, 97,                                     // 11467:    case 0x0: {
  OPC_SwitchField, 4, 1,                     // 11469:     switch Inst[4] {
  0, 45,                                     // 11472:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 11474:      switch Inst[31:28] {
  14, 19,                                    // 11477:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11479:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11481:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11485:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11489:       check Inst[0] == 0x0
  OPC_Decode, 203, 13, 225, 1,               // 11493:       decode to MVE_VSHL_by_vecs8 using decoder 225
                                             // 11493:      }
  15, 0,                                     // 11498:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11500:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11502:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11506:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11510:       check Inst[0] == 0x0
  OPC_Decode, 206, 13, 225, 1,               // 11514:       decode to MVE_VSHL_by_vecu8 using decoder 225
                                             // 11514:      }
                                             // 11514:      } // switch Inst[31:28]
                                             // 11514:     }
  1, 0,                                      // 11519:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 11521:      switch Inst[31:28] {
  14, 19,                                    // 11524:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11526:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11528:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11532:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11536:       check Inst[0] == 0x0
  OPC_Decode, 208, 12, 225, 1,               // 11540:       decode to MVE_VQSHL_by_vecs8 using decoder 225
                                             // 11540:      }
  15, 0,                                     // 11545:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11547:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11549:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11553:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11557:       check Inst[0] == 0x0
  OPC_Decode, 211, 12, 225, 1,               // 11561:       decode to MVE_VQSHL_by_vecu8 using decoder 225
                                             // 11561:      }
                                             // 11561:      } // switch Inst[31:28]
                                             // 11561:     }
                                             // 11561:     } // switch Inst[4]
                                             // 11561:    }
  1, 97,                                     // 11566:    case 0x1: {
  OPC_SwitchField, 4, 1,                     // 11568:     switch Inst[4] {
  0, 45,                                     // 11571:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 11573:      switch Inst[31:28] {
  14, 19,                                    // 11576:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11578:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11580:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11584:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11588:       check Inst[0] == 0x0
  OPC_Decode, 201, 13, 225, 1,               // 11592:       decode to MVE_VSHL_by_vecs16 using decoder 225
                                             // 11592:      }
  15, 0,                                     // 11597:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11599:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11601:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11605:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11609:       check Inst[0] == 0x0
  OPC_Decode, 204, 13, 225, 1,               // 11613:       decode to MVE_VSHL_by_vecu16 using decoder 225
                                             // 11613:      }
                                             // 11613:      } // switch Inst[31:28]
                                             // 11613:     }
  1, 0,                                      // 11618:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 11620:      switch Inst[31:28] {
  14, 19,                                    // 11623:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11625:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11627:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11631:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11635:       check Inst[0] == 0x0
  OPC_Decode, 206, 12, 225, 1,               // 11639:       decode to MVE_VQSHL_by_vecs16 using decoder 225
                                             // 11639:      }
  15, 0,                                     // 11644:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11646:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11648:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11652:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11656:       check Inst[0] == 0x0
  OPC_Decode, 209, 12, 225, 1,               // 11660:       decode to MVE_VQSHL_by_vecu16 using decoder 225
                                             // 11660:      }
                                             // 11660:      } // switch Inst[31:28]
                                             // 11660:     }
                                             // 11660:     } // switch Inst[4]
                                             // 11660:    }
  2, 0,                                      // 11665:    case 0x2: {
  OPC_SwitchField, 4, 1,                     // 11667:     switch Inst[4] {
  0, 45,                                     // 11670:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 11672:      switch Inst[31:28] {
  14, 19,                                    // 11675:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11677:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11679:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11683:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11687:       check Inst[0] == 0x0
  OPC_Decode, 202, 13, 225, 1,               // 11691:       decode to MVE_VSHL_by_vecs32 using decoder 225
                                             // 11691:      }
  15, 0,                                     // 11696:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11698:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11700:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11704:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11708:       check Inst[0] == 0x0
  OPC_Decode, 205, 13, 225, 1,               // 11712:       decode to MVE_VSHL_by_vecu32 using decoder 225
                                             // 11712:      }
                                             // 11712:      } // switch Inst[31:28]
                                             // 11712:     }
  1, 0,                                      // 11717:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 11719:      switch Inst[31:28] {
  14, 19,                                    // 11722:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11724:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11726:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11730:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11734:       check Inst[0] == 0x0
  OPC_Decode, 207, 12, 225, 1,               // 11738:       decode to MVE_VQSHL_by_vecs32 using decoder 225
                                             // 11738:      }
  15, 0,                                     // 11743:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11745:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11747:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11751:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11755:       check Inst[0] == 0x0
  OPC_Decode, 210, 12, 225, 1,               // 11759:       decode to MVE_VQSHL_by_vecu32 using decoder 225
                                             // 11759:      }
                                             // 11759:      } // switch Inst[31:28]
                                             // 11759:     }
                                             // 11759:     } // switch Inst[4]
                                             // 11759:    }
                                             // 11759:    } // switch Inst[21:20]
                                             // 11759:   }
  5, 172, 2,                                 // 11764:   case 0x5: {
  OPC_SwitchField, 20, 2,                    // 11767:    switch Inst[21:20] {
  0, 97,                                     // 11770:    case 0x0: {
  OPC_SwitchField, 4, 1,                     // 11772:     switch Inst[4] {
  0, 45,                                     // 11775:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 11777:      switch Inst[31:28] {
  14, 19,                                    // 11780:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11782:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11784:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11788:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11792:       check Inst[0] == 0x0
  OPC_Decode, 162, 13, 225, 1,               // 11796:       decode to MVE_VRSHL_by_vecs8 using decoder 225
                                             // 11796:      }
  15, 0,                                     // 11801:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11803:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11805:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11809:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11813:       check Inst[0] == 0x0
  OPC_Decode, 165, 13, 225, 1,               // 11817:       decode to MVE_VRSHL_by_vecu8 using decoder 225
                                             // 11817:      }
                                             // 11817:      } // switch Inst[31:28]
                                             // 11817:     }
  1, 0,                                      // 11822:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 11824:      switch Inst[31:28] {
  14, 19,                                    // 11827:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11829:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11831:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11835:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11839:       check Inst[0] == 0x0
  OPC_Decode, 181, 12, 225, 1,               // 11843:       decode to MVE_VQRSHL_by_vecs8 using decoder 225
                                             // 11843:      }
  15, 0,                                     // 11848:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11850:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11852:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11856:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11860:       check Inst[0] == 0x0
  OPC_Decode, 184, 12, 225, 1,               // 11864:       decode to MVE_VQRSHL_by_vecu8 using decoder 225
                                             // 11864:      }
                                             // 11864:      } // switch Inst[31:28]
                                             // 11864:     }
                                             // 11864:     } // switch Inst[4]
                                             // 11864:    }
  1, 97,                                     // 11869:    case 0x1: {
  OPC_SwitchField, 4, 1,                     // 11871:     switch Inst[4] {
  0, 45,                                     // 11874:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 11876:      switch Inst[31:28] {
  14, 19,                                    // 11879:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11881:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11883:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11887:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11891:       check Inst[0] == 0x0
  OPC_Decode, 160, 13, 225, 1,               // 11895:       decode to MVE_VRSHL_by_vecs16 using decoder 225
                                             // 11895:      }
  15, 0,                                     // 11900:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11902:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11904:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11908:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11912:       check Inst[0] == 0x0
  OPC_Decode, 163, 13, 225, 1,               // 11916:       decode to MVE_VRSHL_by_vecu16 using decoder 225
                                             // 11916:      }
                                             // 11916:      } // switch Inst[31:28]
                                             // 11916:     }
  1, 0,                                      // 11921:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 11923:      switch Inst[31:28] {
  14, 19,                                    // 11926:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11928:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11930:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11934:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11938:       check Inst[0] == 0x0
  OPC_Decode, 179, 12, 225, 1,               // 11942:       decode to MVE_VQRSHL_by_vecs16 using decoder 225
                                             // 11942:      }
  15, 0,                                     // 11947:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 11949:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11951:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11955:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11959:       check Inst[0] == 0x0
  OPC_Decode, 182, 12, 225, 1,               // 11963:       decode to MVE_VQRSHL_by_vecu16 using decoder 225
                                             // 11963:      }
                                             // 11963:      } // switch Inst[31:28]
                                             // 11963:     }
                                             // 11963:     } // switch Inst[4]
                                             // 11963:    }
  2, 0,                                      // 11968:    case 0x2: {
  OPC_SwitchField, 4, 1,                     // 11970:     switch Inst[4] {
  0, 45,                                     // 11973:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 11975:      switch Inst[31:28] {
  14, 19,                                    // 11978:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 11980:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 11982:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 11986:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 11990:       check Inst[0] == 0x0
  OPC_Decode, 161, 13, 225, 1,               // 11994:       decode to MVE_VRSHL_by_vecs32 using decoder 225
                                             // 11994:      }
  15, 0,                                     // 11999:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 12001:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12003:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12007:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12011:       check Inst[0] == 0x0
  OPC_Decode, 164, 13, 225, 1,               // 12015:       decode to MVE_VRSHL_by_vecu32 using decoder 225
                                             // 12015:      }
                                             // 12015:      } // switch Inst[31:28]
                                             // 12015:     }
  1, 0,                                      // 12020:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 12022:      switch Inst[31:28] {
  14, 19,                                    // 12025:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 12027:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12029:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12033:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12037:       check Inst[0] == 0x0
  OPC_Decode, 180, 12, 225, 1,               // 12041:       decode to MVE_VQRSHL_by_vecs32 using decoder 225
                                             // 12041:      }
  15, 0,                                     // 12046:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 12048:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12050:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12054:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12058:       check Inst[0] == 0x0
  OPC_Decode, 183, 12, 225, 1,               // 12062:       decode to MVE_VQRSHL_by_vecu32 using decoder 225
                                             // 12062:      }
                                             // 12062:      } // switch Inst[31:28]
                                             // 12062:     }
                                             // 12062:     } // switch Inst[4]
                                             // 12062:    }
                                             // 12062:    } // switch Inst[21:20]
                                             // 12062:   }
  6, 172, 2,                                 // 12067:   case 0x6: {
  OPC_SwitchField, 20, 2,                    // 12070:    switch Inst[21:20] {
  0, 97,                                     // 12073:    case 0x0: {
  OPC_SwitchField, 4, 1,                     // 12075:     switch Inst[4] {
  0, 45,                                     // 12078:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 12080:      switch Inst[31:28] {
  14, 19,                                    // 12083:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 12085:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12087:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12091:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12095:       check Inst[0] == 0x0
  OPC_Decode, 167, 10, 179, 1,               // 12099:       decode to MVE_VMAXs8 using decoder 179
                                             // 12099:      }
  15, 0,                                     // 12104:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 12106:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12108:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12112:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12116:       check Inst[0] == 0x0
  OPC_Decode, 170, 10, 179, 1,               // 12120:       decode to MVE_VMAXu8 using decoder 179
                                             // 12120:      }
                                             // 12120:      } // switch Inst[31:28]
                                             // 12120:     }
  1, 0,                                      // 12125:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 12127:      switch Inst[31:28] {
  14, 19,                                    // 12130:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 12132:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12134:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12138:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12142:       check Inst[0] == 0x0
  OPC_Decode, 193, 10, 179, 1,               // 12146:       decode to MVE_VMINs8 using decoder 179
                                             // 12146:      }
  15, 0,                                     // 12151:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 12153:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12155:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12159:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12163:       check Inst[0] == 0x0
  OPC_Decode, 196, 10, 179, 1,               // 12167:       decode to MVE_VMINu8 using decoder 179
                                             // 12167:      }
                                             // 12167:      } // switch Inst[31:28]
                                             // 12167:     }
                                             // 12167:     } // switch Inst[4]
                                             // 12167:    }
  1, 97,                                     // 12172:    case 0x1: {
  OPC_SwitchField, 4, 1,                     // 12174:     switch Inst[4] {
  0, 45,                                     // 12177:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 12179:      switch Inst[31:28] {
  14, 19,                                    // 12182:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 12184:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12186:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12190:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12194:       check Inst[0] == 0x0
  OPC_Decode, 165, 10, 179, 1,               // 12198:       decode to MVE_VMAXs16 using decoder 179
                                             // 12198:      }
  15, 0,                                     // 12203:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 12205:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12207:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12211:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12215:       check Inst[0] == 0x0
  OPC_Decode, 168, 10, 179, 1,               // 12219:       decode to MVE_VMAXu16 using decoder 179
                                             // 12219:      }
                                             // 12219:      } // switch Inst[31:28]
                                             // 12219:     }
  1, 0,                                      // 12224:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 12226:      switch Inst[31:28] {
  14, 19,                                    // 12229:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 12231:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12233:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12237:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12241:       check Inst[0] == 0x0
  OPC_Decode, 191, 10, 179, 1,               // 12245:       decode to MVE_VMINs16 using decoder 179
                                             // 12245:      }
  15, 0,                                     // 12250:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 12252:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12254:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12258:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12262:       check Inst[0] == 0x0
  OPC_Decode, 194, 10, 179, 1,               // 12266:       decode to MVE_VMINu16 using decoder 179
                                             // 12266:      }
                                             // 12266:      } // switch Inst[31:28]
                                             // 12266:     }
                                             // 12266:     } // switch Inst[4]
                                             // 12266:    }
  2, 0,                                      // 12271:    case 0x2: {
  OPC_SwitchField, 4, 1,                     // 12273:     switch Inst[4] {
  0, 45,                                     // 12276:     case 0x0: {
  OPC_SwitchField, 28, 4,                    // 12278:      switch Inst[31:28] {
  14, 19,                                    // 12281:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 12283:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12285:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12289:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12293:       check Inst[0] == 0x0
  OPC_Decode, 166, 10, 179, 1,               // 12297:       decode to MVE_VMAXs32 using decoder 179
                                             // 12297:      }
  15, 0,                                     // 12302:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 12304:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12306:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12310:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12314:       check Inst[0] == 0x0
  OPC_Decode, 169, 10, 179, 1,               // 12318:       decode to MVE_VMAXu32 using decoder 179
                                             // 12318:      }
                                             // 12318:      } // switch Inst[31:28]
                                             // 12318:     }
  1, 0,                                      // 12323:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 12325:      switch Inst[31:28] {
  14, 19,                                    // 12328:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 12330:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12332:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12336:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12340:       check Inst[0] == 0x0
  OPC_Decode, 192, 10, 179, 1,               // 12344:       decode to MVE_VMINs32 using decoder 179
                                             // 12344:      }
  15, 0,                                     // 12349:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 12351:       check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12353:       check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12357:       check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12361:       check Inst[0] == 0x0
  OPC_Decode, 195, 10, 179, 1,               // 12365:       decode to MVE_VMINu32 using decoder 179
                                             // 12365:      }
                                             // 12365:      } // switch Inst[31:28]
                                             // 12365:     }
                                             // 12365:     } // switch Inst[4]
                                             // 12365:    }
                                             // 12365:    } // switch Inst[21:20]
                                             // 12365:   }
  7, 168, 1,                                 // 12370:   case 0x7: {
  OPC_SwitchField, 20, 2,                    // 12373:    switch Inst[21:20] {
  0, 53,                                     // 12376:    case 0x0: {
  OPC_SwitchField, 28, 4,                    // 12378:     switch Inst[31:28] {
  14, 23,                                    // 12381:     case 0xe: {
  OPC_CheckPredicate, 31,                    // 12383:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12385:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12389:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12393:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12397:      check Inst[0] == 0x0
  OPC_Decode, 147, 8, 179, 1,                // 12401:      decode to MVE_VABDs8 using decoder 179
                                             // 12401:     }
  15, 0,                                     // 12406:     case 0xf: {
  OPC_CheckPredicate, 31,                    // 12408:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12410:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12414:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12418:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12422:      check Inst[0] == 0x0
  OPC_Decode, 150, 8, 179, 1,                // 12426:      decode to MVE_VABDu8 using decoder 179
                                             // 12426:     }
                                             // 12426:     } // switch Inst[31:28]
                                             // 12426:    }
  1, 53,                                     // 12431:    case 0x1: {
  OPC_SwitchField, 28, 4,                    // 12433:     switch Inst[31:28] {
  14, 23,                                    // 12436:     case 0xe: {
  OPC_CheckPredicate, 31,                    // 12438:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12440:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12444:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12448:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12452:      check Inst[0] == 0x0
  OPC_Decode, 145, 8, 179, 1,                // 12456:      decode to MVE_VABDs16 using decoder 179
                                             // 12456:     }
  15, 0,                                     // 12461:     case 0xf: {
  OPC_CheckPredicate, 31,                    // 12463:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12465:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12469:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12473:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12477:      check Inst[0] == 0x0
  OPC_Decode, 148, 8, 179, 1,                // 12481:      decode to MVE_VABDu16 using decoder 179
                                             // 12481:     }
                                             // 12481:     } // switch Inst[31:28]
                                             // 12481:    }
  2, 0,                                      // 12486:    case 0x2: {
  OPC_SwitchField, 28, 4,                    // 12488:     switch Inst[31:28] {
  14, 23,                                    // 12491:     case 0xe: {
  OPC_CheckPredicate, 31,                    // 12493:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12495:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12499:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12503:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12507:      check Inst[0] == 0x0
  OPC_Decode, 146, 8, 179, 1,                // 12511:      decode to MVE_VABDs32 using decoder 179
                                             // 12511:     }
  15, 0,                                     // 12516:     case 0xf: {
  OPC_CheckPredicate, 31,                    // 12518:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12520:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12524:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12528:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12532:      check Inst[0] == 0x0
  OPC_Decode, 149, 8, 179, 1,                // 12536:      decode to MVE_VABDu32 using decoder 179
                                             // 12536:     }
                                             // 12536:     } // switch Inst[31:28]
                                             // 12536:    }
                                             // 12536:    } // switch Inst[21:20]
                                             // 12536:   }
  8, 168, 1,                                 // 12541:   case 0x8: {
  OPC_SwitchField, 20, 2,                    // 12544:    switch Inst[21:20] {
  0, 53,                                     // 12547:    case 0x0: {
  OPC_SwitchField, 28, 4,                    // 12549:     switch Inst[31:28] {
  14, 23,                                    // 12552:     case 0xe: {
  OPC_CheckPredicate, 31,                    // 12554:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12556:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12560:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12564:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12568:      check Inst[0] == 0x0
  OPC_Decode, 183, 8, 179, 1,                // 12572:      decode to MVE_VADDi8 using decoder 179
                                             // 12572:     }
  15, 0,                                     // 12577:     case 0xf: {
  OPC_CheckPredicate, 31,                    // 12579:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12581:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12585:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12589:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12593:      check Inst[0] == 0x0
  OPC_Decode, 182, 14, 179, 1,               // 12597:      decode to MVE_VSUBi8 using decoder 179
                                             // 12597:     }
                                             // 12597:     } // switch Inst[31:28]
                                             // 12597:    }
  1, 53,                                     // 12602:    case 0x1: {
  OPC_SwitchField, 28, 4,                    // 12604:     switch Inst[31:28] {
  14, 23,                                    // 12607:     case 0xe: {
  OPC_CheckPredicate, 31,                    // 12609:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12611:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12615:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12619:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12623:      check Inst[0] == 0x0
  OPC_Decode, 181, 8, 179, 1,                // 12627:      decode to MVE_VADDi16 using decoder 179
                                             // 12627:     }
  15, 0,                                     // 12632:     case 0xf: {
  OPC_CheckPredicate, 31,                    // 12634:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12636:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12640:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12644:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12648:      check Inst[0] == 0x0
  OPC_Decode, 180, 14, 179, 1,               // 12652:      decode to MVE_VSUBi16 using decoder 179
                                             // 12652:     }
                                             // 12652:     } // switch Inst[31:28]
                                             // 12652:    }
  2, 0,                                      // 12657:    case 0x2: {
  OPC_SwitchField, 28, 4,                    // 12659:     switch Inst[31:28] {
  14, 23,                                    // 12662:     case 0xe: {
  OPC_CheckPredicate, 31,                    // 12664:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12666:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12670:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12674:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12678:      check Inst[0] == 0x0
  OPC_Decode, 182, 8, 179, 1,                // 12682:      decode to MVE_VADDi32 using decoder 179
                                             // 12682:     }
  15, 0,                                     // 12687:     case 0xf: {
  OPC_CheckPredicate, 31,                    // 12689:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12691:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12695:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12699:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12703:      check Inst[0] == 0x0
  OPC_Decode, 181, 14, 179, 1,               // 12707:      decode to MVE_VSUBi32 using decoder 179
                                             // 12707:     }
                                             // 12707:     } // switch Inst[31:28]
                                             // 12707:    }
                                             // 12707:    } // switch Inst[21:20]
                                             // 12707:   }
  9, 90,                                     // 12712:   case 0x9: {
  OPC_SwitchField, 20, 2,                    // 12714:    switch Inst[21:20] {
  0, 27,                                     // 12717:    case 0x0: {
  OPC_CheckPredicate, 31,                    // 12719:     check predicate 31
  OPC_CheckField, 28, 4, 14,                 // 12721:     check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 12725:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12729:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 12733:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12737:     check Inst[0] == 0x0
  OPC_Decode, 183, 11, 179, 1,               // 12741:     decode to MVE_VMULi8 using decoder 179
                                             // 12741:    }
  1, 27,                                     // 12746:    case 0x1: {
  OPC_CheckPredicate, 31,                    // 12748:     check predicate 31
  OPC_CheckField, 28, 4, 14,                 // 12750:     check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 12754:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12758:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 12762:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12766:     check Inst[0] == 0x0
  OPC_Decode, 181, 11, 179, 1,               // 12770:     decode to MVE_VMULi16 using decoder 179
                                             // 12770:    }
  2, 0,                                      // 12775:    case 0x2: {
  OPC_CheckPredicate, 31,                    // 12777:     check predicate 31
  OPC_CheckField, 28, 4, 14,                 // 12779:     check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 12783:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12787:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 12791:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 12795:     check Inst[0] == 0x0
  OPC_Decode, 182, 11, 179, 1,               // 12799:     decode to MVE_VMULi32 using decoder 179
                                             // 12799:    }
                                             // 12799:    } // switch Inst[21:20]
                                             // 12799:   }
  11, 168, 1,                                // 12804:   case 0xb: {
  OPC_SwitchField, 20, 2,                    // 12807:    switch Inst[21:20] {
  0, 53,                                     // 12810:    case 0x0: {
  OPC_SwitchField, 28, 4,                    // 12812:     switch Inst[31:28] {
  14, 23,                                    // 12815:     case 0xe: {
  OPC_CheckPredicate, 31,                    // 12817:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12819:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12823:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12827:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12831:      check Inst[0] == 0x0
  OPC_Decode, 131, 12, 179, 1,               // 12835:      decode to MVE_VQDMULHi8 using decoder 179
                                             // 12835:     }
  15, 0,                                     // 12840:     case 0xf: {
  OPC_CheckPredicate, 31,                    // 12842:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12844:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12848:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12852:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12856:      check Inst[0] == 0x0
  OPC_Decode, 178, 12, 179, 1,               // 12860:      decode to MVE_VQRDMULHi8 using decoder 179
                                             // 12860:     }
                                             // 12860:     } // switch Inst[31:28]
                                             // 12860:    }
  1, 53,                                     // 12865:    case 0x1: {
  OPC_SwitchField, 28, 4,                    // 12867:     switch Inst[31:28] {
  14, 23,                                    // 12870:     case 0xe: {
  OPC_CheckPredicate, 31,                    // 12872:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12874:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12878:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12882:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12886:      check Inst[0] == 0x0
  OPC_Decode, 129, 12, 179, 1,               // 12890:      decode to MVE_VQDMULHi16 using decoder 179
                                             // 12890:     }
  15, 0,                                     // 12895:     case 0xf: {
  OPC_CheckPredicate, 31,                    // 12897:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12899:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12903:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12907:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12911:      check Inst[0] == 0x0
  OPC_Decode, 176, 12, 179, 1,               // 12915:      decode to MVE_VQRDMULHi16 using decoder 179
                                             // 12915:     }
                                             // 12915:     } // switch Inst[31:28]
                                             // 12915:    }
  2, 0,                                      // 12920:    case 0x2: {
  OPC_SwitchField, 28, 4,                    // 12922:     switch Inst[31:28] {
  14, 23,                                    // 12925:     case 0xe: {
  OPC_CheckPredicate, 31,                    // 12927:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12929:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12933:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12937:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12941:      check Inst[0] == 0x0
  OPC_Decode, 130, 12, 179, 1,               // 12945:      decode to MVE_VQDMULHi32 using decoder 179
                                             // 12945:     }
  15, 0,                                     // 12950:     case 0xf: {
  OPC_CheckPredicate, 31,                    // 12952:      check predicate 31
  OPC_CheckField, 16, 1, 0,                  // 12954:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12958:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 12962:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 12966:      check Inst[0] == 0x0
  OPC_Decode, 177, 12, 179, 1,               // 12970:      decode to MVE_VQRDMULHi32 using decoder 179
                                             // 12970:     }
                                             // 12970:     } // switch Inst[31:28]
                                             // 12970:    }
                                             // 12970:    } // switch Inst[21:20]
                                             // 12970:   }
  12, 119,                                   // 12975:   case 0xc: {
  OPC_SwitchField, 20, 2,                    // 12977:    switch Inst[21:20] {
  0, 27,                                     // 12980:    case 0x0: {
  OPC_CheckPredicate, 33,                    // 12982:     check predicate 33
  OPC_CheckField, 28, 4, 14,                 // 12984:     check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 12988:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 12992:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 12996:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13000:     check Inst[0] == 0x0
  OPC_Decode, 155, 9, 178, 1,                // 13004:     decode to MVE_VFMAf32 using decoder 178
                                             // 13004:    }
  1, 27,                                     // 13009:    case 0x1: {
  OPC_CheckPredicate, 33,                    // 13011:     check predicate 33
  OPC_CheckField, 28, 4, 14,                 // 13013:     check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 13017:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13021:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 13025:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13029:     check Inst[0] == 0x0
  OPC_Decode, 154, 9, 178, 1,                // 13033:     decode to MVE_VFMAf16 using decoder 178
                                             // 13033:    }
  2, 27,                                     // 13038:    case 0x2: {
  OPC_CheckPredicate, 33,                    // 13040:     check predicate 33
  OPC_CheckField, 28, 4, 14,                 // 13042:     check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 13046:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13050:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 13054:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13058:     check Inst[0] == 0x0
  OPC_Decode, 157, 9, 178, 1,                // 13062:     decode to MVE_VFMSf32 using decoder 178
                                             // 13062:    }
  3, 0,                                      // 13067:    case 0x3: {
  OPC_CheckPredicate, 33,                    // 13069:     check predicate 33
  OPC_CheckField, 28, 4, 14,                 // 13071:     check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 13075:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13079:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 13083:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13087:     check Inst[0] == 0x0
  OPC_Decode, 156, 9, 178, 1,                // 13091:     decode to MVE_VFMSf16 using decoder 178
                                             // 13091:    }
                                             // 13091:    } // switch Inst[21:20]
                                             // 13091:   }
  13, 223, 1,                                // 13096:   case 0xd: {
  OPC_SwitchField, 20, 2,                    // 13099:    switch Inst[21:20] {
  0, 53,                                     // 13102:    case 0x0: {
  OPC_SwitchField, 4, 1,                     // 13104:     switch Inst[4] {
  0, 23,                                     // 13107:     case 0x0: {
  OPC_CheckPredicate, 33,                    // 13109:      check predicate 33
  OPC_CheckField, 28, 4, 14,                 // 13111:      check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 13115:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13119:      check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13123:      check Inst[0] == 0x0
  OPC_Decode, 180, 8, 179, 1,                // 13127:      decode to MVE_VADDf32 using decoder 179
                                             // 13127:     }
  1, 0,                                      // 13132:     case 0x1: {
  OPC_CheckPredicate, 33,                    // 13134:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13136:      check Inst[31:28] == 0xf
  OPC_CheckField, 16, 1, 0,                  // 13140:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13144:      check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13148:      check Inst[0] == 0x0
  OPC_Decode, 180, 11, 179, 1,               // 13152:      decode to MVE_VMULf32 using decoder 179
                                             // 13152:     }
                                             // 13152:     } // switch Inst[4]
                                             // 13152:    }
  1, 53,                                     // 13157:    case 0x1: {
  OPC_SwitchField, 4, 1,                     // 13159:     switch Inst[4] {
  0, 23,                                     // 13162:     case 0x0: {
  OPC_CheckPredicate, 33,                    // 13164:      check predicate 33
  OPC_CheckField, 28, 4, 14,                 // 13166:      check Inst[31:28] == 0xe
  OPC_CheckField, 16, 1, 0,                  // 13170:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13174:      check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13178:      check Inst[0] == 0x0
  OPC_Decode, 179, 8, 179, 1,                // 13182:      decode to MVE_VADDf16 using decoder 179
                                             // 13182:     }
  1, 0,                                      // 13187:     case 0x1: {
  OPC_CheckPredicate, 33,                    // 13189:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13191:      check Inst[31:28] == 0xf
  OPC_CheckField, 16, 1, 0,                  // 13195:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13199:      check Inst[6] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13203:      check Inst[0] == 0x0
  OPC_Decode, 179, 11, 179, 1,               // 13207:      decode to MVE_VMULf16 using decoder 179
                                             // 13207:     }
                                             // 13207:     } // switch Inst[4]
                                             // 13207:    }
  2, 53,                                     // 13212:    case 0x2: {
  OPC_SwitchField, 28, 4,                    // 13214:     switch Inst[31:28] {
  14, 23,                                    // 13217:     case 0xe: {
  OPC_CheckPredicate, 33,                    // 13219:      check predicate 33
  OPC_CheckField, 16, 1, 0,                  // 13221:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13225:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 13229:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 13233:      check Inst[0] == 0x0
  OPC_Decode, 179, 14, 179, 1,               // 13237:      decode to MVE_VSUBf32 using decoder 179
                                             // 13237:     }
  15, 0,                                     // 13242:     case 0xf: {
  OPC_CheckPredicate, 33,                    // 13244:      check predicate 33
  OPC_CheckField, 16, 1, 0,                  // 13246:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13250:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 13254:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 13258:      check Inst[0] == 0x0
  OPC_Decode, 144, 8, 179, 1,                // 13262:      decode to MVE_VABDf32 using decoder 179
                                             // 13262:     }
                                             // 13262:     } // switch Inst[31:28]
                                             // 13262:    }
  3, 0,                                      // 13267:    case 0x3: {
  OPC_SwitchField, 28, 4,                    // 13269:     switch Inst[31:28] {
  14, 23,                                    // 13272:     case 0xe: {
  OPC_CheckPredicate, 33,                    // 13274:      check predicate 33
  OPC_CheckField, 16, 1, 0,                  // 13276:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13280:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 13284:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 13288:      check Inst[0] == 0x0
  OPC_Decode, 178, 14, 179, 1,               // 13292:      decode to MVE_VSUBf16 using decoder 179
                                             // 13292:     }
  15, 0,                                     // 13297:     case 0xf: {
  OPC_CheckPredicate, 33,                    // 13299:      check predicate 33
  OPC_CheckField, 16, 1, 0,                  // 13301:      check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13305:      check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 13309:      check Inst[4] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 13313:      check Inst[0] == 0x0
  OPC_Decode, 143, 8, 179, 1,                // 13317:      decode to MVE_VABDf16 using decoder 179
                                             // 13317:     }
                                             // 13317:     } // switch Inst[31:28]
                                             // 13317:    }
                                             // 13317:    } // switch Inst[21:20]
                                             // 13317:   }
  15, 0,                                     // 13322:   case 0xf: {
  OPC_SwitchField, 20, 2,                    // 13324:    switch Inst[21:20] {
  0, 27,                                     // 13327:    case 0x0: {
  OPC_CheckPredicate, 33,                    // 13329:     check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13331:     check Inst[31:28] == 0xf
  OPC_CheckField, 16, 1, 0,                  // 13335:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13339:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 13343:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13347:     check Inst[0] == 0x0
  OPC_Decode, 158, 10, 179, 1,               // 13351:     decode to MVE_VMAXNMf32 using decoder 179
                                             // 13351:    }
  1, 27,                                     // 13356:    case 0x1: {
  OPC_CheckPredicate, 33,                    // 13358:     check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13360:     check Inst[31:28] == 0xf
  OPC_CheckField, 16, 1, 0,                  // 13364:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13368:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 13372:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13376:     check Inst[0] == 0x0
  OPC_Decode, 157, 10, 179, 1,               // 13380:     decode to MVE_VMAXNMf16 using decoder 179
                                             // 13380:    }
  2, 27,                                     // 13385:    case 0x2: {
  OPC_CheckPredicate, 33,                    // 13387:     check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13389:     check Inst[31:28] == 0xf
  OPC_CheckField, 16, 1, 0,                  // 13393:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13397:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 13401:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13405:     check Inst[0] == 0x0
  OPC_Decode, 184, 10, 179, 1,               // 13409:     decode to MVE_VMINNMf32 using decoder 179
                                             // 13409:    }
  3, 0,                                      // 13414:    case 0x3: {
  OPC_CheckPredicate, 33,                    // 13416:     check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13418:     check Inst[31:28] == 0xf
  OPC_CheckField, 16, 1, 0,                  // 13422:     check Inst[16] == 0x0
  OPC_CheckField, 6, 1, 1,                   // 13426:     check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 1,                   // 13430:     check Inst[4] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 13434:     check Inst[0] == 0x0
  OPC_Decode, 183, 10, 179, 1,               // 13438:     decode to MVE_VMINNMf16 using decoder 179
                                             // 13438:    }
                                             // 13438:    } // switch Inst[21:20]
                                             // 13438:   }
                                             // 13438:   } // switch Inst[12:8]
                                             // 13438:  }
  3, 0,                                      // 13443:  case 0x3: {
  OPC_SwitchField, 4, 1,                     // 13445:   switch Inst[4] {
  0, 164, 9,                                 // 13448:   case 0x0: {
  OPC_SwitchField, 6, 7,                     // 13451:    switch Inst[12:6] {
  1, 88,                                     // 13454:    case 0x1: {
  OPC_SwitchField, 16, 6,                    // 13456:     switch Inst[21:16] {
  48, 15,                                    // 13459:     case 0x30: {
  OPC_CheckPredicate, 31,                    // 13461:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13463:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13467:      check Inst[0] == 0x0
  OPC_Decode, 253, 12, 183, 1,               // 13471:      decode to MVE_VREV64_8 using decoder 183
                                             // 13471:     }
  52, 15,                                    // 13476:     case 0x34: {
  OPC_CheckPredicate, 31,                    // 13478:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13480:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13484:      check Inst[0] == 0x0
  OPC_Decode, 251, 12, 183, 1,               // 13488:      decode to MVE_VREV64_16 using decoder 183
                                             // 13488:     }
  55, 15,                                    // 13493:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 13495:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13497:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13501:      check Inst[0] == 0x0
  OPC_Decode, 245, 8, 183, 1,                // 13505:      decode to MVE_VCVTs16f16a using decoder 183
                                             // 13505:     }
  56, 15,                                    // 13510:     case 0x38: {
  OPC_CheckPredicate, 31,                    // 13512:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13514:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13518:      check Inst[0] == 0x0
  OPC_Decode, 252, 12, 183, 1,               // 13522:      decode to MVE_VREV64_32 using decoder 183
                                             // 13522:     }
  59, 0,                                     // 13527:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 13529:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13531:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13535:      check Inst[0] == 0x0
  OPC_Decode, 251, 8, 183, 1,                // 13539:      decode to MVE_VCVTs32f32a using decoder 183
                                             // 13539:     }
                                             // 13539:     } // switch Inst[21:16]
                                             // 13539:    }
  3, 71,                                     // 13544:    case 0x3: {
  OPC_SwitchField, 16, 6,                    // 13546:     switch Inst[21:16] {
  48, 15,                                    // 13549:     case 0x30: {
  OPC_CheckPredicate, 31,                    // 13551:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13553:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13557:      check Inst[0] == 0x0
  OPC_Decode, 250, 12, 183, 1,               // 13561:      decode to MVE_VREV32_8 using decoder 183
                                             // 13561:     }
  52, 15,                                    // 13566:     case 0x34: {
  OPC_CheckPredicate, 31,                    // 13568:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13570:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13574:      check Inst[0] == 0x0
  OPC_Decode, 249, 12, 183, 1,               // 13578:      decode to MVE_VREV32_16 using decoder 183
                                             // 13578:     }
  55, 15,                                    // 13583:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 13585:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13587:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13591:      check Inst[0] == 0x0
  OPC_Decode, 129, 9, 183, 1,                // 13595:      decode to MVE_VCVTu16f16a using decoder 183
                                             // 13595:     }
  59, 0,                                     // 13600:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 13602:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13604:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13608:      check Inst[0] == 0x0
  OPC_Decode, 135, 9, 183, 1,                // 13612:      decode to MVE_VCVTu32f32a using decoder 183
                                             // 13612:     }
                                             // 13612:     } // switch Inst[21:16]
                                             // 13612:    }
  5, 54,                                     // 13617:    case 0x5: {
  OPC_SwitchField, 16, 6,                    // 13619:     switch Inst[21:16] {
  48, 15,                                    // 13622:     case 0x30: {
  OPC_CheckPredicate, 31,                    // 13624:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13626:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13630:      check Inst[0] == 0x0
  OPC_Decode, 248, 12, 183, 1,               // 13634:      decode to MVE_VREV16_8 using decoder 183
                                             // 13634:     }
  55, 15,                                    // 13639:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 13641:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13643:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13647:      check Inst[0] == 0x0
  OPC_Decode, 247, 8, 183, 1,                // 13651:      decode to MVE_VCVTs16f16n using decoder 183
                                             // 13651:     }
  59, 0,                                     // 13656:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 13658:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13660:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13664:      check Inst[0] == 0x0
  OPC_Decode, 253, 8, 183, 1,                // 13668:      decode to MVE_VCVTs32f32n using decoder 183
                                             // 13668:     }
                                             // 13668:     } // switch Inst[21:16]
                                             // 13668:    }
  7, 37,                                     // 13673:    case 0x7: {
  OPC_SwitchField, 16, 6,                    // 13675:     switch Inst[21:16] {
  55, 15,                                    // 13678:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 13680:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13682:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13686:      check Inst[0] == 0x0
  OPC_Decode, 131, 9, 183, 1,                // 13690:      decode to MVE_VCVTu16f16n using decoder 183
                                             // 13690:     }
  59, 0,                                     // 13695:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 13697:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13699:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13703:      check Inst[0] == 0x0
  OPC_Decode, 137, 9, 183, 1,                // 13707:      decode to MVE_VCVTu32f32n using decoder 183
                                             // 13707:     }
                                             // 13707:     } // switch Inst[21:16]
                                             // 13707:    }
  9, 37,                                     // 13712:    case 0x9: {
  OPC_SwitchField, 16, 6,                    // 13714:     switch Inst[21:16] {
  55, 15,                                    // 13717:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 13719:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13721:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13725:      check Inst[0] == 0x0
  OPC_Decode, 248, 8, 183, 1,                // 13729:      decode to MVE_VCVTs16f16p using decoder 183
                                             // 13729:     }
  59, 0,                                     // 13734:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 13736:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13738:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13742:      check Inst[0] == 0x0
  OPC_Decode, 254, 8, 183, 1,                // 13746:      decode to MVE_VCVTs32f32p using decoder 183
                                             // 13746:     }
                                             // 13746:     } // switch Inst[21:16]
                                             // 13746:    }
  11, 37,                                    // 13751:    case 0xb: {
  OPC_SwitchField, 16, 6,                    // 13753:     switch Inst[21:16] {
  55, 15,                                    // 13756:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 13758:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13760:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13764:      check Inst[0] == 0x0
  OPC_Decode, 132, 9, 183, 1,                // 13768:      decode to MVE_VCVTu16f16p using decoder 183
                                             // 13768:     }
  59, 0,                                     // 13773:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 13775:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13777:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13781:      check Inst[0] == 0x0
  OPC_Decode, 138, 9, 183, 1,                // 13785:      decode to MVE_VCVTu32f32p using decoder 183
                                             // 13785:     }
                                             // 13785:     } // switch Inst[21:16]
                                             // 13785:    }
  13, 88,                                    // 13790:    case 0xd: {
  OPC_SwitchField, 16, 6,                    // 13792:     switch Inst[21:16] {
  49, 15,                                    // 13795:     case 0x31: {
  OPC_CheckPredicate, 31,                    // 13797:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13799:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13803:      check Inst[0] == 0x0
  OPC_Decode, 155, 8, 183, 1,                // 13807:      decode to MVE_VABSs8 using decoder 183
                                             // 13807:     }
  53, 15,                                    // 13812:     case 0x35: {
  OPC_CheckPredicate, 31,                    // 13814:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13816:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13820:      check Inst[0] == 0x0
  OPC_Decode, 153, 8, 183, 1,                // 13824:      decode to MVE_VABSs16 using decoder 183
                                             // 13824:     }
  55, 15,                                    // 13829:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 13831:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13833:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13837:      check Inst[0] == 0x0
  OPC_Decode, 246, 8, 183, 1,                // 13841:      decode to MVE_VCVTs16f16m using decoder 183
                                             // 13841:     }
  57, 15,                                    // 13846:     case 0x39: {
  OPC_CheckPredicate, 31,                    // 13848:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13850:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13854:      check Inst[0] == 0x0
  OPC_Decode, 154, 8, 183, 1,                // 13858:      decode to MVE_VABSs32 using decoder 183
                                             // 13858:     }
  59, 0,                                     // 13863:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 13865:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13867:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13871:      check Inst[0] == 0x0
  OPC_Decode, 252, 8, 183, 1,                // 13875:      decode to MVE_VCVTs32f32m using decoder 183
                                             // 13875:     }
                                             // 13875:     } // switch Inst[21:16]
                                             // 13875:    }
  15, 88,                                    // 13880:    case 0xf: {
  OPC_SwitchField, 16, 6,                    // 13882:     switch Inst[21:16] {
  49, 15,                                    // 13885:     case 0x31: {
  OPC_CheckPredicate, 31,                    // 13887:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13889:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13893:      check Inst[0] == 0x0
  OPC_Decode, 191, 11, 183, 1,               // 13897:      decode to MVE_VNEGs8 using decoder 183
                                             // 13897:     }
  53, 15,                                    // 13902:     case 0x35: {
  OPC_CheckPredicate, 31,                    // 13904:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13906:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13910:      check Inst[0] == 0x0
  OPC_Decode, 189, 11, 183, 1,               // 13914:      decode to MVE_VNEGs16 using decoder 183
                                             // 13914:     }
  55, 15,                                    // 13919:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 13921:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13923:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13927:      check Inst[0] == 0x0
  OPC_Decode, 130, 9, 183, 1,                // 13931:      decode to MVE_VCVTu16f16m using decoder 183
                                             // 13931:     }
  57, 15,                                    // 13936:     case 0x39: {
  OPC_CheckPredicate, 31,                    // 13938:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13940:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13944:      check Inst[0] == 0x0
  OPC_Decode, 190, 11, 183, 1,               // 13948:      decode to MVE_VNEGs32 using decoder 183
                                             // 13948:     }
  59, 0,                                     // 13953:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 13955:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 13957:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13961:      check Inst[0] == 0x0
  OPC_Decode, 136, 9, 183, 1,                // 13965:      decode to MVE_VCVTu32f32m using decoder 183
                                             // 13965:     }
                                             // 13965:     } // switch Inst[21:16]
                                             // 13965:    }
  17, 88,                                    // 13970:    case 0x11: {
  OPC_SwitchField, 16, 6,                    // 13972:     switch Inst[21:16] {
  48, 15,                                    // 13975:     case 0x30: {
  OPC_CheckPredicate, 31,                    // 13977:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13979:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 13983:      check Inst[0] == 0x0
  OPC_Decode, 198, 8, 183, 1,                // 13987:      decode to MVE_VCLSs8 using decoder 183
                                             // 13987:     }
  52, 15,                                    // 13992:     case 0x34: {
  OPC_CheckPredicate, 31,                    // 13994:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 13996:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14000:      check Inst[0] == 0x0
  OPC_Decode, 196, 8, 183, 1,                // 14004:      decode to MVE_VCLSs16 using decoder 183
                                             // 14004:     }
  54, 15,                                    // 14009:     case 0x36: {
  OPC_CheckPredicate, 33,                    // 14011:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14013:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14017:      check Inst[0] == 0x0
  OPC_Decode, 134, 13, 183, 1,               // 14021:      decode to MVE_VRINTf16N using decoder 183
                                             // 14021:     }
  56, 15,                                    // 14026:     case 0x38: {
  OPC_CheckPredicate, 31,                    // 14028:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14030:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14034:      check Inst[0] == 0x0
  OPC_Decode, 197, 8, 183, 1,                // 14038:      decode to MVE_VCLSs32 using decoder 183
                                             // 14038:     }
  58, 0,                                     // 14043:     case 0x3a: {
  OPC_CheckPredicate, 33,                    // 14045:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14047:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14051:      check Inst[0] == 0x0
  OPC_Decode, 140, 13, 183, 1,               // 14055:      decode to MVE_VRINTf32N using decoder 183
                                             // 14055:     }
                                             // 14055:     } // switch Inst[21:16]
                                             // 14055:    }
  19, 88,                                    // 14060:    case 0x13: {
  OPC_SwitchField, 16, 6,                    // 14062:     switch Inst[21:16] {
  48, 15,                                    // 14065:     case 0x30: {
  OPC_CheckPredicate, 31,                    // 14067:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14069:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14073:      check Inst[0] == 0x0
  OPC_Decode, 201, 8, 183, 1,                // 14077:      decode to MVE_VCLZs8 using decoder 183
                                             // 14077:     }
  52, 15,                                    // 14082:     case 0x34: {
  OPC_CheckPredicate, 31,                    // 14084:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14086:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14090:      check Inst[0] == 0x0
  OPC_Decode, 199, 8, 183, 1,                // 14094:      decode to MVE_VCLZs16 using decoder 183
                                             // 14094:     }
  54, 15,                                    // 14099:     case 0x36: {
  OPC_CheckPredicate, 33,                    // 14101:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14103:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14107:      check Inst[0] == 0x0
  OPC_Decode, 136, 13, 183, 1,               // 14111:      decode to MVE_VRINTf16X using decoder 183
                                             // 14111:     }
  56, 15,                                    // 14116:     case 0x38: {
  OPC_CheckPredicate, 31,                    // 14118:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14120:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14124:      check Inst[0] == 0x0
  OPC_Decode, 200, 8, 183, 1,                // 14128:      decode to MVE_VCLZs32 using decoder 183
                                             // 14128:     }
  58, 0,                                     // 14133:     case 0x3a: {
  OPC_CheckPredicate, 33,                    // 14135:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14137:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14141:      check Inst[0] == 0x0
  OPC_Decode, 142, 13, 183, 1,               // 14145:      decode to MVE_VRINTf32X using decoder 183
                                             // 14145:     }
                                             // 14145:     } // switch Inst[21:16]
                                             // 14145:    }
  21, 37,                                    // 14150:    case 0x15: {
  OPC_SwitchField, 16, 6,                    // 14152:     switch Inst[21:16] {
  54, 15,                                    // 14155:     case 0x36: {
  OPC_CheckPredicate, 33,                    // 14157:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14159:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14163:      check Inst[0] == 0x0
  OPC_Decode, 132, 13, 183, 1,               // 14167:      decode to MVE_VRINTf16A using decoder 183
                                             // 14167:     }
  58, 0,                                     // 14172:     case 0x3a: {
  OPC_CheckPredicate, 33,                    // 14174:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14176:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14180:      check Inst[0] == 0x0
  OPC_Decode, 138, 13, 183, 1,               // 14184:      decode to MVE_VRINTf32A using decoder 183
                                             // 14184:     }
                                             // 14184:     } // switch Inst[21:16]
                                             // 14184:    }
  23, 54,                                    // 14189:    case 0x17: {
  OPC_SwitchField, 16, 6,                    // 14191:     switch Inst[21:16] {
  48, 15,                                    // 14194:     case 0x30: {
  OPC_CheckPredicate, 31,                    // 14196:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14198:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14202:      check Inst[0] == 0x0
  OPC_Decode, 184, 11, 183, 1,               // 14206:      decode to MVE_VMVN using decoder 183
                                             // 14206:     }
  54, 15,                                    // 14211:     case 0x36: {
  OPC_CheckPredicate, 33,                    // 14213:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14215:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14219:      check Inst[0] == 0x0
  OPC_Decode, 137, 13, 183, 1,               // 14223:      decode to MVE_VRINTf16Z using decoder 183
                                             // 14223:     }
  58, 0,                                     // 14228:     case 0x3a: {
  OPC_CheckPredicate, 33,                    // 14230:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14232:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14236:      check Inst[0] == 0x0
  OPC_Decode, 143, 13, 183, 1,               // 14240:      decode to MVE_VRINTf32Z using decoder 183
                                             // 14240:     }
                                             // 14240:     } // switch Inst[21:16]
                                             // 14240:    }
  25, 37,                                    // 14245:    case 0x19: {
  OPC_SwitchField, 16, 6,                    // 14247:     switch Inst[21:16] {
  55, 15,                                    // 14250:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 14252:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14254:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14258:      check Inst[0] == 0x0
  OPC_Decode, 235, 8, 183, 1,                // 14262:      decode to MVE_VCVTf16s16n using decoder 183
                                             // 14262:     }
  59, 0,                                     // 14267:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 14269:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14271:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14275:      check Inst[0] == 0x0
  OPC_Decode, 241, 8, 183, 1,                // 14279:      decode to MVE_VCVTf32s32n using decoder 183
                                             // 14279:     }
                                             // 14279:     } // switch Inst[21:16]
                                             // 14279:    }
  27, 71,                                    // 14284:    case 0x1b: {
  OPC_SwitchField, 16, 6,                    // 14286:     switch Inst[21:16] {
  54, 15,                                    // 14289:     case 0x36: {
  OPC_CheckPredicate, 33,                    // 14291:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14293:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14297:      check Inst[0] == 0x0
  OPC_Decode, 133, 13, 183, 1,               // 14301:      decode to MVE_VRINTf16M using decoder 183
                                             // 14301:     }
  55, 15,                                    // 14306:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 14308:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14310:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14314:      check Inst[0] == 0x0
  OPC_Decode, 237, 8, 183, 1,                // 14318:      decode to MVE_VCVTf16u16n using decoder 183
                                             // 14318:     }
  58, 15,                                    // 14323:     case 0x3a: {
  OPC_CheckPredicate, 33,                    // 14325:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14327:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14331:      check Inst[0] == 0x0
  OPC_Decode, 139, 13, 183, 1,               // 14335:      decode to MVE_VRINTf32M using decoder 183
                                             // 14335:     }
  59, 0,                                     // 14340:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 14342:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14344:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14348:      check Inst[0] == 0x0
  OPC_Decode, 243, 8, 183, 1,                // 14352:      decode to MVE_VCVTf32u32n using decoder 183
                                             // 14352:     }
                                             // 14352:     } // switch Inst[21:16]
                                             // 14352:    }
  29, 122,                                   // 14357:    case 0x1d: {
  OPC_SwitchField, 16, 6,                    // 14359:     switch Inst[21:16] {
  48, 15,                                    // 14362:     case 0x30: {
  OPC_CheckPredicate, 31,                    // 14364:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14366:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14370:      check Inst[0] == 0x0
  OPC_Decode, 223, 11, 183, 1,               // 14374:      decode to MVE_VQABSs8 using decoder 183
                                             // 14374:     }
  52, 15,                                    // 14379:     case 0x34: {
  OPC_CheckPredicate, 31,                    // 14381:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14383:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14387:      check Inst[0] == 0x0
  OPC_Decode, 221, 11, 183, 1,               // 14391:      decode to MVE_VQABSs16 using decoder 183
                                             // 14391:     }
  53, 15,                                    // 14396:     case 0x35: {
  OPC_CheckPredicate, 33,                    // 14398:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14400:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14404:      check Inst[0] == 0x0
  OPC_Decode, 151, 8, 183, 1,                // 14408:      decode to MVE_VABSf16 using decoder 183
                                             // 14408:     }
  55, 15,                                    // 14413:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 14415:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14417:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14421:      check Inst[0] == 0x0
  OPC_Decode, 249, 8, 183, 1,                // 14425:      decode to MVE_VCVTs16f16z using decoder 183
                                             // 14425:     }
  56, 15,                                    // 14430:     case 0x38: {
  OPC_CheckPredicate, 31,                    // 14432:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14434:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14438:      check Inst[0] == 0x0
  OPC_Decode, 222, 11, 183, 1,               // 14442:      decode to MVE_VQABSs32 using decoder 183
                                             // 14442:     }
  57, 15,                                    // 14447:     case 0x39: {
  OPC_CheckPredicate, 33,                    // 14449:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14451:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14455:      check Inst[0] == 0x0
  OPC_Decode, 152, 8, 183, 1,                // 14459:      decode to MVE_VABSf32 using decoder 183
                                             // 14459:     }
  59, 0,                                     // 14464:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 14466:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14468:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14472:      check Inst[0] == 0x0
  OPC_Decode, 255, 8, 183, 1,                // 14476:      decode to MVE_VCVTs32f32z using decoder 183
                                             // 14476:     }
                                             // 14476:     } // switch Inst[21:16]
                                             // 14476:    }
  31, 0,                                     // 14481:    case 0x1f: {
  OPC_SwitchField, 16, 6,                    // 14483:     switch Inst[21:16] {
  48, 15,                                    // 14486:     case 0x30: {
  OPC_CheckPredicate, 31,                    // 14488:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14490:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14494:      check Inst[0] == 0x0
  OPC_Decode, 154, 12, 183, 1,               // 14498:      decode to MVE_VQNEGs8 using decoder 183
                                             // 14498:     }
  52, 15,                                    // 14503:     case 0x34: {
  OPC_CheckPredicate, 31,                    // 14505:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14507:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14511:      check Inst[0] == 0x0
  OPC_Decode, 152, 12, 183, 1,               // 14515:      decode to MVE_VQNEGs16 using decoder 183
                                             // 14515:     }
  53, 15,                                    // 14520:     case 0x35: {
  OPC_CheckPredicate, 33,                    // 14522:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14524:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14528:      check Inst[0] == 0x0
  OPC_Decode, 187, 11, 183, 1,               // 14532:      decode to MVE_VNEGf16 using decoder 183
                                             // 14532:     }
  54, 15,                                    // 14537:     case 0x36: {
  OPC_CheckPredicate, 33,                    // 14539:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14541:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14545:      check Inst[0] == 0x0
  OPC_Decode, 135, 13, 183, 1,               // 14549:      decode to MVE_VRINTf16P using decoder 183
                                             // 14549:     }
  55, 15,                                    // 14554:     case 0x37: {
  OPC_CheckPredicate, 33,                    // 14556:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14558:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14562:      check Inst[0] == 0x0
  OPC_Decode, 133, 9, 183, 1,                // 14566:      decode to MVE_VCVTu16f16z using decoder 183
                                             // 14566:     }
  56, 15,                                    // 14571:     case 0x38: {
  OPC_CheckPredicate, 31,                    // 14573:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14575:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14579:      check Inst[0] == 0x0
  OPC_Decode, 153, 12, 183, 1,               // 14583:      decode to MVE_VQNEGs32 using decoder 183
                                             // 14583:     }
  57, 15,                                    // 14588:     case 0x39: {
  OPC_CheckPredicate, 33,                    // 14590:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14592:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14596:      check Inst[0] == 0x0
  OPC_Decode, 188, 11, 183, 1,               // 14600:      decode to MVE_VNEGf32 using decoder 183
                                             // 14600:     }
  58, 15,                                    // 14605:     case 0x3a: {
  OPC_CheckPredicate, 33,                    // 14607:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14609:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14613:      check Inst[0] == 0x0
  OPC_Decode, 141, 13, 183, 1,               // 14617:      decode to MVE_VRINTf32P using decoder 183
                                             // 14617:     }
  59, 0,                                     // 14622:     case 0x3b: {
  OPC_CheckPredicate, 33,                    // 14624:      check predicate 33
  OPC_CheckField, 28, 4, 15,                 // 14626:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14630:      check Inst[0] == 0x0
  OPC_Decode, 139, 9, 183, 1,                // 14634:      decode to MVE_VCVTu32f32z using decoder 183
                                             // 14634:     }
                                             // 14634:     } // switch Inst[21:16]
                                             // 14634:    }
                                             // 14634:    } // switch Inst[12:6]
                                             // 14634:   }
  1, 0,                                      // 14639:   case 0x1: {
  OPC_SwitchField, 21, 1,                    // 14641:    switch Inst[21] {
  0, 245, 3,                                 // 14644:    case 0x0: {
  OPC_SwitchField, 20, 1,                    // 14647:     switch Inst[20] {
  0, 204, 2,                                 // 14650:     case 0x0: {
  OPC_SwitchField, 19, 1,                    // 14653:      switch Inst[19] {
  0, 163, 1,                                 // 14656:      case 0x0: {
  OPC_SwitchField, 5, 3,                     // 14659:       switch Inst[7:5] {
  2, 83,                                     // 14662:       case 0x2: {
  OPC_CheckField, 12, 1, 0,                  // 14664:        check Inst[12] == 0x0
  OPC_CheckField, 29, 3, 7,                  // 14668:        check Inst[31:29] == 0x7
  OPC_Scope, 21,                             // 14672:        try {
  OPC_SwitchField, 8, 4,                     // 14674:         switch Inst[11:8] {
  14, 7,                                     // 14677:         case 0xe: {
  OPC_CheckPredicate, 31,                    // 14679:          check predicate 31
  OPC_Decode, 151, 11, 226, 1,               // 14681:          decode to MVE_VMOVimmi8 using decoder 226
                                             // 14681:         }
  15, 0,                                     // 14686:         case 0xf: {
  OPC_CheckPredicate, 31,                    // 14688:          check predicate 31
  OPC_Decode, 147, 11, 226, 1,               // 14690:          decode to MVE_VMOVimmf32 using decoder 226
                                             // 14690:         }
                                             // 14690:         } // switch Inst[11:8]
  OPC_Scope, 43,                             // 14695:        } else try {
  OPC_SwitchField, 8, 1,                     // 14697:         switch Inst[8] {
  0, 11,                                     // 14700:         case 0x0: {
  OPC_CheckPredicate, 31,                    // 14702:          check predicate 31
  OPC_CheckField, 10, 2, 2,                  // 14704:          check Inst[11:10] == 0x2
  OPC_Decode, 148, 11, 226, 1,               // 14708:          decode to MVE_VMOVimmi16 using decoder 226
                                             // 14708:         }
  1, 0,                                      // 14713:         case 0x1: {
  OPC_SwitchField, 11, 1,                    // 14715:          switch Inst[11] {
  0, 7,                                      // 14718:          case 0x0: {
  OPC_CheckPredicate, 31,                    // 14720:           check predicate 31
  OPC_Decode, 195, 11, 227, 1,               // 14722:           decode to MVE_VORRimmi32 using decoder 227
                                             // 14722:          }
  1, 0,                                      // 14727:          case 0x1: {
  OPC_CheckPredicate, 31,                    // 14729:           check predicate 31
  OPC_CheckField, 10, 1, 0,                  // 14731:           check Inst[10] == 0x0
  OPC_Decode, 194, 11, 228, 1,               // 14735:           decode to MVE_VORRimmi16 using decoder 228
                                             // 14735:          }
                                             // 14735:          } // switch Inst[11]
                                             // 14735:         }
                                             // 14735:         } // switch Inst[8]
                                             // 14735:        } else try {
  OPC_CheckPredicate, 31,                    // 14740:         check predicate 31
  OPC_Decode, 149, 11, 226, 1,               // 14742:         decode to MVE_VMOVimmi32 using decoder 226
                                             // 14742:        }
                                             // 14742:       }
  3, 0,                                      // 14747:       case 0x3: {
  OPC_CheckField, 12, 1, 0,                  // 14749:        check Inst[12] == 0x0
  OPC_CheckField, 29, 3, 7,                  // 14753:        check Inst[31:29] == 0x7
  OPC_Scope, 11,                             // 14757:        try {
  OPC_CheckField, 8, 4, 14,                  // 14759:         check Inst[11:8] == 0xe
  OPC_CheckPredicate, 31,                    // 14763:         check predicate 31
  OPC_Decode, 150, 11, 226, 1,               // 14765:         decode to MVE_VMOVimmi64 using decoder 226
  OPC_Scope, 43,                             // 14770:        } else try {
  OPC_SwitchField, 8, 1,                     // 14772:         switch Inst[8] {
  0, 11,                                     // 14775:         case 0x0: {
  OPC_CheckPredicate, 31,                    // 14777:          check predicate 31
  OPC_CheckField, 10, 2, 2,                  // 14779:          check Inst[11:10] == 0x2
  OPC_Decode, 185, 11, 226, 1,               // 14783:          decode to MVE_VMVNimmi16 using decoder 226
                                             // 14783:         }
  1, 0,                                      // 14788:         case 0x1: {
  OPC_SwitchField, 11, 1,                    // 14790:          switch Inst[11] {
  0, 7,                                      // 14793:          case 0x0: {
  OPC_CheckPredicate, 31,                    // 14795:           check predicate 31
  OPC_Decode, 187, 8, 227, 1,                // 14797:           decode to MVE_VBICimmi32 using decoder 227
                                             // 14797:          }
  1, 0,                                      // 14802:          case 0x1: {
  OPC_CheckPredicate, 31,                    // 14804:           check predicate 31
  OPC_CheckField, 10, 1, 0,                  // 14806:           check Inst[10] == 0x0
  OPC_Decode, 186, 8, 228, 1,                // 14810:           decode to MVE_VBICimmi16 using decoder 228
                                             // 14810:          }
                                             // 14810:          } // switch Inst[11]
                                             // 14810:         }
                                             // 14810:         } // switch Inst[8]
                                             // 14810:        } else try {
  OPC_CheckPredicate, 31,                    // 14815:         check predicate 31
  OPC_Decode, 186, 11, 226, 1,               // 14817:         decode to MVE_VMVNimmi32 using decoder 226
                                             // 14817:        }
                                             // 14817:       }
                                             // 14817:       } // switch Inst[7:5]
                                             // 14817:      }
  1, 0,                                      // 14822:      case 0x1: {
  OPC_SwitchField, 6, 7,                     // 14824:       switch Inst[12:6] {
  1, 29,                                     // 14827:       case 0x1: {
  OPC_SwitchField, 28, 4,                    // 14829:        switch Inst[31:28] {
  14, 11,                                    // 14832:        case 0xe: {
  OPC_CheckPredicate, 31,                    // 14834:         check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 14836:         check Inst[0] == 0x0
  OPC_Decode, 222, 13, 229, 1,               // 14840:         decode to MVE_VSHR_imms8 using decoder 229
                                             // 14840:        }
  15, 0,                                     // 14845:        case 0xf: {
  OPC_CheckPredicate, 31,                    // 14847:         check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 14849:         check Inst[0] == 0x0
  OPC_Decode, 225, 13, 229, 1,               // 14853:         decode to MVE_VSHR_immu8 using decoder 229
                                             // 14853:        }
                                             // 14853:        } // switch Inst[31:28]
                                             // 14853:       }
  9, 29,                                     // 14858:       case 0x9: {
  OPC_SwitchField, 28, 4,                    // 14860:        switch Inst[31:28] {
  14, 11,                                    // 14863:        case 0xe: {
  OPC_CheckPredicate, 31,                    // 14865:         check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 14867:         check Inst[0] == 0x0
  OPC_Decode, 178, 13, 229, 1,               // 14871:         decode to MVE_VRSHR_imms8 using decoder 229
                                             // 14871:        }
  15, 0,                                     // 14876:        case 0xf: {
  OPC_CheckPredicate, 31,                    // 14878:         check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 14880:         check Inst[0] == 0x0
  OPC_Decode, 181, 13, 229, 1,               // 14884:         decode to MVE_VRSHR_immu8 using decoder 229
                                             // 14884:        }
                                             // 14884:        } // switch Inst[31:28]
                                             // 14884:       }
  17, 15,                                    // 14889:       case 0x11: {
  OPC_CheckPredicate, 31,                    // 14891:        check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14893:        check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14897:        check Inst[0] == 0x0
  OPC_Decode, 231, 13, 220, 1,               // 14901:        decode to MVE_VSRIimm8 using decoder 220
                                             // 14901:       }
  21, 29,                                    // 14906:       case 0x15: {
  OPC_SwitchField, 28, 4,                    // 14908:        switch Inst[31:28] {
  14, 11,                                    // 14911:        case 0xe: {
  OPC_CheckPredicate, 31,                    // 14913:         check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 14915:         check Inst[0] == 0x0
  OPC_Decode, 209, 13, 222, 1,               // 14919:         decode to MVE_VSHL_immi8 using decoder 222
                                             // 14919:        }
  15, 0,                                     // 14924:        case 0xf: {
  OPC_CheckPredicate, 31,                    // 14926:         check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 14928:         check Inst[0] == 0x0
  OPC_Decode, 228, 13, 230, 1,               // 14932:         decode to MVE_VSLIimm8 using decoder 230
                                             // 14932:        }
                                             // 14932:        } // switch Inst[31:28]
                                             // 14932:       }
  25, 15,                                    // 14937:       case 0x19: {
  OPC_CheckPredicate, 31,                    // 14939:        check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 14941:        check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 14945:        check Inst[0] == 0x0
  OPC_Decode, 205, 12, 222, 1,               // 14949:        decode to MVE_VQSHLU_imms8 using decoder 222
                                             // 14949:       }
  29, 0,                                     // 14954:       case 0x1d: {
  OPC_SwitchField, 28, 4,                    // 14956:        switch Inst[31:28] {
  14, 11,                                    // 14959:        case 0xe: {
  OPC_CheckPredicate, 31,                    // 14961:         check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 14963:         check Inst[0] == 0x0
  OPC_Decode, 220, 12, 222, 1,               // 14967:         decode to MVE_VQSHLimms8 using decoder 222
                                             // 14967:        }
  15, 0,                                     // 14972:        case 0xf: {
  OPC_CheckPredicate, 31,                    // 14974:         check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 14976:         check Inst[0] == 0x0
  OPC_Decode, 223, 12, 222, 1,               // 14980:         decode to MVE_VQSHLimmu8 using decoder 222
                                             // 14980:        }
                                             // 14980:        } // switch Inst[31:28]
                                             // 14980:       }
                                             // 14980:       } // switch Inst[12:6]
                                             // 14980:      }
                                             // 14980:      } // switch Inst[19]
                                             // 14980:     }
  1, 0,                                      // 14985:     case 0x1: {
  OPC_SwitchField, 6, 7,                     // 14987:      switch Inst[12:6] {
  1, 29,                                     // 14990:      case 0x1: {
  OPC_SwitchField, 28, 4,                    // 14992:       switch Inst[31:28] {
  14, 11,                                    // 14995:       case 0xe: {
  OPC_CheckPredicate, 31,                    // 14997:        check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 14999:        check Inst[0] == 0x0
  OPC_Decode, 220, 13, 231, 1,               // 15003:        decode to MVE_VSHR_imms16 using decoder 231
                                             // 15003:       }
  15, 0,                                     // 15008:       case 0xf: {
  OPC_CheckPredicate, 31,                    // 15010:        check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15012:        check Inst[0] == 0x0
  OPC_Decode, 223, 13, 231, 1,               // 15016:        decode to MVE_VSHR_immu16 using decoder 231
                                             // 15016:       }
                                             // 15016:       } // switch Inst[31:28]
                                             // 15016:      }
  9, 29,                                     // 15021:      case 0x9: {
  OPC_SwitchField, 28, 4,                    // 15023:       switch Inst[31:28] {
  14, 11,                                    // 15026:       case 0xe: {
  OPC_CheckPredicate, 31,                    // 15028:        check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15030:        check Inst[0] == 0x0
  OPC_Decode, 176, 13, 231, 1,               // 15034:        decode to MVE_VRSHR_imms16 using decoder 231
                                             // 15034:       }
  15, 0,                                     // 15039:       case 0xf: {
  OPC_CheckPredicate, 31,                    // 15041:        check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15043:        check Inst[0] == 0x0
  OPC_Decode, 179, 13, 231, 1,               // 15047:        decode to MVE_VRSHR_immu16 using decoder 231
                                             // 15047:       }
                                             // 15047:       } // switch Inst[31:28]
                                             // 15047:      }
  17, 15,                                    // 15052:      case 0x11: {
  OPC_CheckPredicate, 31,                    // 15054:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 15056:       check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 15060:       check Inst[0] == 0x0
  OPC_Decode, 229, 13, 221, 1,               // 15064:       decode to MVE_VSRIimm16 using decoder 221
                                             // 15064:      }
  21, 29,                                    // 15069:      case 0x15: {
  OPC_SwitchField, 28, 4,                    // 15071:       switch Inst[31:28] {
  14, 11,                                    // 15074:       case 0xe: {
  OPC_CheckPredicate, 31,                    // 15076:        check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15078:        check Inst[0] == 0x0
  OPC_Decode, 207, 13, 223, 1,               // 15082:        decode to MVE_VSHL_immi16 using decoder 223
                                             // 15082:       }
  15, 0,                                     // 15087:       case 0xf: {
  OPC_CheckPredicate, 31,                    // 15089:        check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15091:        check Inst[0] == 0x0
  OPC_Decode, 226, 13, 232, 1,               // 15095:        decode to MVE_VSLIimm16 using decoder 232
                                             // 15095:       }
                                             // 15095:       } // switch Inst[31:28]
                                             // 15095:      }
  25, 15,                                    // 15100:      case 0x19: {
  OPC_CheckPredicate, 31,                    // 15102:       check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 15104:       check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 15108:       check Inst[0] == 0x0
  OPC_Decode, 203, 12, 223, 1,               // 15112:       decode to MVE_VQSHLU_imms16 using decoder 223
                                             // 15112:      }
  29, 0,                                     // 15117:      case 0x1d: {
  OPC_SwitchField, 28, 4,                    // 15119:       switch Inst[31:28] {
  14, 11,                                    // 15122:       case 0xe: {
  OPC_CheckPredicate, 31,                    // 15124:        check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15126:        check Inst[0] == 0x0
  OPC_Decode, 218, 12, 223, 1,               // 15130:        decode to MVE_VQSHLimms16 using decoder 223
                                             // 15130:       }
  15, 0,                                     // 15135:       case 0xf: {
  OPC_CheckPredicate, 31,                    // 15137:        check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15139:        check Inst[0] == 0x0
  OPC_Decode, 221, 12, 223, 1,               // 15143:        decode to MVE_VQSHLimmu16 using decoder 223
                                             // 15143:       }
                                             // 15143:       } // switch Inst[31:28]
                                             // 15143:      }
                                             // 15143:      } // switch Inst[12:6]
                                             // 15143:     }
                                             // 15143:     } // switch Inst[20]
                                             // 15143:    }
  1, 0,                                      // 15148:    case 0x1: {
  OPC_SwitchField, 6, 7,                     // 15150:     switch Inst[12:6] {
  1, 29,                                     // 15153:     case 0x1: {
  OPC_SwitchField, 28, 4,                    // 15155:      switch Inst[31:28] {
  14, 11,                                    // 15158:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 15160:       check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15162:       check Inst[0] == 0x0
  OPC_Decode, 221, 13, 233, 1,               // 15166:       decode to MVE_VSHR_imms32 using decoder 233
                                             // 15166:      }
  15, 0,                                     // 15171:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 15173:       check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15175:       check Inst[0] == 0x0
  OPC_Decode, 224, 13, 233, 1,               // 15179:       decode to MVE_VSHR_immu32 using decoder 233
                                             // 15179:      }
                                             // 15179:      } // switch Inst[31:28]
                                             // 15179:     }
  9, 29,                                     // 15184:     case 0x9: {
  OPC_SwitchField, 28, 4,                    // 15186:      switch Inst[31:28] {
  14, 11,                                    // 15189:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 15191:       check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15193:       check Inst[0] == 0x0
  OPC_Decode, 177, 13, 233, 1,               // 15197:       decode to MVE_VRSHR_imms32 using decoder 233
                                             // 15197:      }
  15, 0,                                     // 15202:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 15204:       check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15206:       check Inst[0] == 0x0
  OPC_Decode, 180, 13, 233, 1,               // 15210:       decode to MVE_VRSHR_immu32 using decoder 233
                                             // 15210:      }
                                             // 15210:      } // switch Inst[31:28]
                                             // 15210:     }
  17, 15,                                    // 15215:     case 0x11: {
  OPC_CheckPredicate, 31,                    // 15217:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 15219:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 15223:      check Inst[0] == 0x0
  OPC_Decode, 230, 13, 234, 1,               // 15227:      decode to MVE_VSRIimm32 using decoder 234
                                             // 15227:     }
  21, 29,                                    // 15232:     case 0x15: {
  OPC_SwitchField, 28, 4,                    // 15234:      switch Inst[31:28] {
  14, 11,                                    // 15237:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 15239:       check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15241:       check Inst[0] == 0x0
  OPC_Decode, 208, 13, 235, 1,               // 15245:       decode to MVE_VSHL_immi32 using decoder 235
                                             // 15245:      }
  15, 0,                                     // 15250:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 15252:       check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15254:       check Inst[0] == 0x0
  OPC_Decode, 227, 13, 236, 1,               // 15258:       decode to MVE_VSLIimm32 using decoder 236
                                             // 15258:      }
                                             // 15258:      } // switch Inst[31:28]
                                             // 15258:     }
  25, 15,                                    // 15263:     case 0x19: {
  OPC_CheckPredicate, 31,                    // 15265:      check predicate 31
  OPC_CheckField, 28, 4, 15,                 // 15267:      check Inst[31:28] == 0xf
  OPC_CheckField, 0, 1, 0,                   // 15271:      check Inst[0] == 0x0
  OPC_Decode, 204, 12, 235, 1,               // 15275:      decode to MVE_VQSHLU_imms32 using decoder 235
                                             // 15275:     }
  29, 29,                                    // 15280:     case 0x1d: {
  OPC_SwitchField, 28, 4,                    // 15282:      switch Inst[31:28] {
  14, 11,                                    // 15285:      case 0xe: {
  OPC_CheckPredicate, 31,                    // 15287:       check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15289:       check Inst[0] == 0x0
  OPC_Decode, 219, 12, 235, 1,               // 15293:       decode to MVE_VQSHLimms32 using decoder 235
                                             // 15293:      }
  15, 0,                                     // 15298:      case 0xf: {
  OPC_CheckPredicate, 31,                    // 15300:       check predicate 31
  OPC_CheckField, 0, 1, 0,                   // 15302:       check Inst[0] == 0x0
  OPC_Decode, 222, 12, 235, 1,               // 15306:       decode to MVE_VQSHLimmu32 using decoder 235
                                             // 15306:      }
                                             // 15306:      } // switch Inst[31:28]
                                             // 15306:     }
  49, 37,                                    // 15311:     case 0x31: {
  OPC_SwitchField, 28, 4,                    // 15313:      switch Inst[31:28] {
  14, 15,                                    // 15316:      case 0xe: {
  OPC_CheckPredicate, 33,                    // 15318:       check predicate 33
  OPC_CheckField, 20, 1, 1,                  // 15320:       check Inst[20] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 15324:       check Inst[0] == 0x0
  OPC_Decode, 234, 8, 237, 1,                // 15328:       decode to MVE_VCVTf16s16_fix using decoder 237
                                             // 15328:      }
  15, 0,                                     // 15333:      case 0xf: {
  OPC_CheckPredicate, 33,                    // 15335:       check predicate 33
  OPC_CheckField, 20, 1, 1,                  // 15337:       check Inst[20] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 15341:       check Inst[0] == 0x0
  OPC_Decode, 236, 8, 237, 1,                // 15345:       decode to MVE_VCVTf16u16_fix using decoder 237
                                             // 15345:      }
                                             // 15345:      } // switch Inst[31:28]
                                             // 15345:     }
  53, 37,                                    // 15350:     case 0x35: {
  OPC_SwitchField, 28, 4,                    // 15352:      switch Inst[31:28] {
  14, 15,                                    // 15355:      case 0xe: {
  OPC_CheckPredicate, 33,                    // 15357:       check predicate 33
  OPC_CheckField, 20, 1, 1,                  // 15359:       check Inst[20] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 15363:       check Inst[0] == 0x0
  OPC_Decode, 244, 8, 237, 1,                // 15367:       decode to MVE_VCVTs16f16_fix using decoder 237
                                             // 15367:      }
  15, 0,                                     // 15372:      case 0xf: {
  OPC_CheckPredicate, 33,                    // 15374:       check predicate 33
  OPC_CheckField, 20, 1, 1,                  // 15376:       check Inst[20] == 0x1
  OPC_CheckField, 0, 1, 0,                   // 15380:       check Inst[0] == 0x0
  OPC_Decode, 128, 9, 237, 1,                // 15384:       decode to MVE_VCVTu16f16_fix using decoder 237
                                             // 15384:      }
                                             // 15384:      } // switch Inst[31:28]
                                             // 15384:     }
  57, 29,                                    // 15389:     case 0x39: {
  OPC_SwitchField, 28, 4,                    // 15391:      switch Inst[31:28] {
  14, 11,                                    // 15394:      case 0xe: {
  OPC_CheckPredicate, 33,                    // 15396:       check predicate 33
  OPC_CheckField, 0, 1, 0,                   // 15398:       check Inst[0] == 0x0
  OPC_Decode, 240, 8, 237, 1,                // 15402:       decode to MVE_VCVTf32s32_fix using decoder 237
                                             // 15402:      }
  15, 0,                                     // 15407:      case 0xf: {
  OPC_CheckPredicate, 33,                    // 15409:       check predicate 33
  OPC_CheckField, 0, 1, 0,                   // 15411:       check Inst[0] == 0x0
  OPC_Decode, 242, 8, 237, 1,                // 15415:       decode to MVE_VCVTf32u32_fix using decoder 237
                                             // 15415:      }
                                             // 15415:      } // switch Inst[31:28]
                                             // 15415:     }
  61, 0,                                     // 15420:     case 0x3d: {
  OPC_SwitchField, 28, 4,                    // 15422:      switch Inst[31:28] {
  14, 11,                                    // 15425:      case 0xe: {
  OPC_CheckPredicate, 33,                    // 15427:       check predicate 33
  OPC_CheckField, 0, 1, 0,                   // 15429:       check Inst[0] == 0x0
  OPC_Decode, 250, 8, 237, 1,                // 15433:       decode to MVE_VCVTs32f32_fix using decoder 237
                                             // 15433:      }
  15, 0,                                     // 15438:      case 0xf: {
  OPC_CheckPredicate, 33,                    // 15440:       check predicate 33
  OPC_CheckField, 0, 1, 0,                   // 15442:       check Inst[0] == 0x0
  OPC_Decode, 134, 9, 237, 1,                // 15446:       decode to MVE_VCVTu32f32_fix using decoder 237
                                             // 15446:      }
                                             // 15446:      } // switch Inst[31:28]
                                             // 15446:     }
                                             // 15446:     } // switch Inst[12:6]
                                             // 15446:    }
                                             // 15446:    } // switch Inst[21]
                                             // 15446:   }
                                             // 15446:   } // switch Inst[4]
                                             // 15446:  }
                                             // 15446:  } // switch Inst[24:23]
                                             // 15446: }
                                             // 15446: } // switch Inst[27:25]
};
static const uint8_t DecoderTableNEONData32[11845] = {
  OPC_SwitchField, 4, 1,                     //     0: switch Inst[4] {
  0, 157, 51,                                //     3: case 0x0: {
  OPC_SwitchField, 20, 2,                    //     6:  switch Inst[21:20] {
  0, 140, 8,                                 //     9:  case 0x0: {
  OPC_SwitchField, 8, 4,                     //    12:   switch Inst[11:8] {
  0, 79,                                     //    15:   case 0x0: {
  OPC_SwitchField, 23, 9,                    //    17:    switch Inst[31:23] {
  228, 3, 21,                                //    20:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //    23:     switch Inst[6] {
  0, 7,                                      //    26:     case 0x0: {
  OPC_CheckPredicate, 35,                    //    28:      check predicate 35
  OPC_Decode, 205, 19, 238, 1,               //    30:      decode to VHADDsv8i8 using decoder 238
                                             //    30:     }
  1, 0,                                      //    35:     case 0x1: {
  OPC_CheckPredicate, 35,                    //    37:      check predicate 35
  OPC_Decode, 200, 19, 239, 1,               //    39:      decode to VHADDsv16i8 using decoder 239
                                             //    39:     }
                                             //    39:     } // switch Inst[6]
                                             //    39:    }
  229, 3, 11,                                //    44:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //    47:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //    49:     check Inst[6] == 0x0
  OPC_Decode, 248, 16, 240, 1,               //    53:     decode to VADDLsv8i16 using decoder 240
                                             //    53:    }
  230, 3, 21,                                //    58:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //    61:     switch Inst[6] {
  0, 7,                                      //    64:     case 0x0: {
  OPC_CheckPredicate, 35,                    //    66:      check predicate 35
  OPC_Decode, 211, 19, 238, 1,               //    68:      decode to VHADDuv8i8 using decoder 238
                                             //    68:     }
  1, 0,                                      //    73:     case 0x1: {
  OPC_CheckPredicate, 35,                    //    75:      check predicate 35
  OPC_Decode, 206, 19, 239, 1,               //    77:      decode to VHADDuv16i8 using decoder 239
                                             //    77:     }
                                             //    77:     } // switch Inst[6]
                                             //    77:    }
  231, 3, 0,                                 //    82:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //    85:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //    87:     check Inst[6] == 0x0
  OPC_Decode, 251, 16, 240, 1,               //    91:     decode to VADDLuv8i16 using decoder 240
                                             //    91:    }
                                             //    91:    } // switch Inst[31:23]
                                             //    91:   }
  1, 79,                                     //    96:   case 0x1: {
  OPC_SwitchField, 23, 9,                    //    98:    switch Inst[31:23] {
  228, 3, 21,                                //   101:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //   104:     switch Inst[6] {
  0, 7,                                      //   107:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   109:      check predicate 35
  OPC_Decode, 187, 26, 238, 1,               //   111:      decode to VRHADDsv8i8 using decoder 238
                                             //   111:     }
  1, 0,                                      //   116:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   118:      check predicate 35
  OPC_Decode, 182, 26, 239, 1,               //   120:      decode to VRHADDsv16i8 using decoder 239
                                             //   120:     }
                                             //   120:     } // switch Inst[6]
                                             //   120:    }
  229, 3, 11,                                //   125:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //   128:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   130:     check Inst[6] == 0x0
  OPC_Decode, 255, 16, 241, 1,               //   134:     decode to VADDWsv8i16 using decoder 241
                                             //   134:    }
  230, 3, 21,                                //   139:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //   142:     switch Inst[6] {
  0, 7,                                      //   145:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   147:      check predicate 35
  OPC_Decode, 193, 26, 238, 1,               //   149:      decode to VRHADDuv8i8 using decoder 238
                                             //   149:     }
  1, 0,                                      //   154:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   156:      check predicate 35
  OPC_Decode, 188, 26, 239, 1,               //   158:      decode to VRHADDuv16i8 using decoder 239
                                             //   158:     }
                                             //   158:     } // switch Inst[6]
                                             //   158:    }
  231, 3, 0,                                 //   163:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //   166:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   168:     check Inst[6] == 0x0
  OPC_Decode, 130, 17, 241, 1,               //   172:     decode to VADDWuv8i16 using decoder 241
                                             //   172:    }
                                             //   172:    } // switch Inst[31:23]
                                             //   172:   }
  2, 79,                                     //   177:   case 0x2: {
  OPC_SwitchField, 23, 9,                    //   179:    switch Inst[31:23] {
  228, 3, 21,                                //   182:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //   185:     switch Inst[6] {
  0, 7,                                      //   188:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   190:      check predicate 35
  OPC_Decode, 217, 19, 238, 1,               //   192:      decode to VHSUBsv8i8 using decoder 238
                                             //   192:     }
  1, 0,                                      //   197:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   199:      check predicate 35
  OPC_Decode, 212, 19, 239, 1,               //   201:      decode to VHSUBsv16i8 using decoder 239
                                             //   201:     }
                                             //   201:     } // switch Inst[6]
                                             //   201:    }
  229, 3, 11,                                //   206:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //   209:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   211:     check Inst[6] == 0x0
  OPC_Decode, 202, 30, 240, 1,               //   215:     decode to VSUBLsv8i16 using decoder 240
                                             //   215:    }
  230, 3, 21,                                //   220:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //   223:     switch Inst[6] {
  0, 7,                                      //   226:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   228:      check predicate 35
  OPC_Decode, 223, 19, 238, 1,               //   230:      decode to VHSUBuv8i8 using decoder 238
                                             //   230:     }
  1, 0,                                      //   235:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   237:      check predicate 35
  OPC_Decode, 218, 19, 239, 1,               //   239:      decode to VHSUBuv16i8 using decoder 239
                                             //   239:     }
                                             //   239:     } // switch Inst[6]
                                             //   239:    }
  231, 3, 0,                                 //   244:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //   247:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   249:     check Inst[6] == 0x0
  OPC_Decode, 205, 30, 240, 1,               //   253:     decode to VSUBLuv8i16 using decoder 240
                                             //   253:    }
                                             //   253:    } // switch Inst[31:23]
                                             //   253:   }
  3, 79,                                     //   258:   case 0x3: {
  OPC_SwitchField, 23, 9,                    //   260:    switch Inst[31:23] {
  228, 3, 21,                                //   263:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //   266:     switch Inst[6] {
  0, 7,                                      //   269:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   271:      check predicate 35
  OPC_Decode, 222, 17, 238, 1,               //   273:      decode to VCGTsv8i8 using decoder 238
                                             //   273:     }
  1, 0,                                      //   278:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   280:      check predicate 35
  OPC_Decode, 217, 17, 239, 1,               //   282:      decode to VCGTsv16i8 using decoder 239
                                             //   282:     }
                                             //   282:     } // switch Inst[6]
                                             //   282:    }
  229, 3, 11,                                //   287:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //   290:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   292:     check Inst[6] == 0x0
  OPC_Decode, 209, 30, 241, 1,               //   296:     decode to VSUBWsv8i16 using decoder 241
                                             //   296:    }
  230, 3, 21,                                //   301:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //   304:     switch Inst[6] {
  0, 7,                                      //   307:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   309:      check predicate 35
  OPC_Decode, 228, 17, 238, 1,               //   311:      decode to VCGTuv8i8 using decoder 238
                                             //   311:     }
  1, 0,                                      //   316:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   318:      check predicate 35
  OPC_Decode, 223, 17, 239, 1,               //   320:      decode to VCGTuv16i8 using decoder 239
                                             //   320:     }
                                             //   320:     } // switch Inst[6]
                                             //   320:    }
  231, 3, 0,                                 //   325:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //   328:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   330:     check Inst[6] == 0x0
  OPC_Decode, 212, 30, 241, 1,               //   334:     decode to VSUBWuv8i16 using decoder 241
                                             //   334:    }
                                             //   334:    } // switch Inst[31:23]
                                             //   334:   }
  4, 79,                                     //   339:   case 0x4: {
  OPC_SwitchField, 23, 9,                    //   341:    switch Inst[31:23] {
  228, 3, 21,                                //   344:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //   347:     switch Inst[6] {
  0, 7,                                      //   350:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   352:      check predicate 35
  OPC_Decode, 220, 27, 242, 1,               //   354:      decode to VSHLsv8i8 using decoder 242
                                             //   354:     }
  1, 0,                                      //   359:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   361:      check predicate 35
  OPC_Decode, 213, 27, 243, 1,               //   363:      decode to VSHLsv16i8 using decoder 243
                                             //   363:     }
                                             //   363:     } // switch Inst[6]
                                             //   363:    }
  229, 3, 11,                                //   368:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //   371:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   373:     check Inst[6] == 0x0
  OPC_Decode, 245, 16, 244, 1,               //   377:     decode to VADDHNv8i8 using decoder 244
                                             //   377:    }
  230, 3, 21,                                //   382:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //   385:     switch Inst[6] {
  0, 7,                                      //   388:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   390:      check predicate 35
  OPC_Decode, 228, 27, 242, 1,               //   392:      decode to VSHLuv8i8 using decoder 242
                                             //   392:     }
  1, 0,                                      //   397:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   399:      check predicate 35
  OPC_Decode, 221, 27, 243, 1,               //   401:      decode to VSHLuv16i8 using decoder 243
                                             //   401:     }
                                             //   401:     } // switch Inst[6]
                                             //   401:    }
  231, 3, 0,                                 //   406:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //   409:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   411:     check Inst[6] == 0x0
  OPC_Decode, 159, 26, 244, 1,               //   415:     decode to VRADDHNv8i8 using decoder 244
                                             //   415:    }
                                             //   415:    } // switch Inst[31:23]
                                             //   415:   }
  5, 79,                                     //   420:   case 0x5: {
  OPC_SwitchField, 23, 9,                    //   422:    switch Inst[31:23] {
  228, 3, 21,                                //   425:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //   428:     switch Inst[6] {
  0, 7,                                      //   431:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   433:      check predicate 35
  OPC_Decode, 246, 26, 242, 1,               //   435:      decode to VRSHLsv8i8 using decoder 242
                                             //   435:     }
  1, 0,                                      //   440:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   442:      check predicate 35
  OPC_Decode, 239, 26, 243, 1,               //   444:      decode to VRSHLsv16i8 using decoder 243
                                             //   444:     }
                                             //   444:     } // switch Inst[6]
                                             //   444:    }
  229, 3, 11,                                //   449:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //   452:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   454:     check Inst[6] == 0x0
  OPC_Decode, 182, 16, 245, 1,               //   458:     decode to VABALsv8i16 using decoder 245
                                             //   458:    }
  230, 3, 21,                                //   463:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //   466:     switch Inst[6] {
  0, 7,                                      //   469:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   471:      check predicate 35
  OPC_Decode, 254, 26, 242, 1,               //   473:      decode to VRSHLuv8i8 using decoder 242
                                             //   473:     }
  1, 0,                                      //   478:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   480:      check predicate 35
  OPC_Decode, 247, 26, 243, 1,               //   482:      decode to VRSHLuv16i8 using decoder 243
                                             //   482:     }
                                             //   482:     } // switch Inst[6]
                                             //   482:    }
  231, 3, 0,                                 //   487:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //   490:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   492:     check Inst[6] == 0x0
  OPC_Decode, 185, 16, 245, 1,               //   496:     decode to VABALuv8i16 using decoder 245
                                             //   496:    }
                                             //   496:    } // switch Inst[31:23]
                                             //   496:   }
  6, 79,                                     //   501:   case 0x6: {
  OPC_SwitchField, 23, 9,                    //   503:    switch Inst[31:23] {
  228, 3, 21,                                //   506:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //   509:     switch Inst[6] {
  0, 7,                                      //   512:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   514:      check predicate 35
  OPC_Decode, 243, 22, 238, 1,               //   516:      decode to VMAXsv8i8 using decoder 238
                                             //   516:     }
  1, 0,                                      //   521:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   523:      check predicate 35
  OPC_Decode, 238, 22, 239, 1,               //   525:      decode to VMAXsv16i8 using decoder 239
                                             //   525:     }
                                             //   525:     } // switch Inst[6]
                                             //   525:    }
  229, 3, 11,                                //   530:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //   533:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   535:     check Inst[6] == 0x0
  OPC_Decode, 199, 30, 244, 1,               //   539:     decode to VSUBHNv8i8 using decoder 244
                                             //   539:    }
  230, 3, 21,                                //   544:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //   547:     switch Inst[6] {
  0, 7,                                      //   550:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   552:      check predicate 35
  OPC_Decode, 249, 22, 238, 1,               //   554:      decode to VMAXuv8i8 using decoder 238
                                             //   554:     }
  1, 0,                                      //   559:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   561:      check predicate 35
  OPC_Decode, 244, 22, 239, 1,               //   563:      decode to VMAXuv16i8 using decoder 239
                                             //   563:     }
                                             //   563:     } // switch Inst[6]
                                             //   563:    }
  231, 3, 0,                                 //   568:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //   571:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   573:     check Inst[6] == 0x0
  OPC_Decode, 174, 27, 244, 1,               //   577:     decode to VRSUBHNv8i8 using decoder 244
                                             //   577:    }
                                             //   577:    } // switch Inst[31:23]
                                             //   577:   }
  7, 79,                                     //   582:   case 0x7: {
  OPC_SwitchField, 23, 9,                    //   584:    switch Inst[31:23] {
  228, 3, 21,                                //   587:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //   590:     switch Inst[6] {
  0, 7,                                      //   593:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   595:      check predicate 35
  OPC_Decode, 213, 16, 238, 1,               //   597:      decode to VABDsv8i8 using decoder 238
                                             //   597:     }
  1, 0,                                      //   602:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   604:      check predicate 35
  OPC_Decode, 208, 16, 239, 1,               //   606:      decode to VABDsv16i8 using decoder 239
                                             //   606:     }
                                             //   606:     } // switch Inst[6]
                                             //   606:    }
  229, 3, 11,                                //   611:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //   614:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   616:     check Inst[6] == 0x0
  OPC_Decode, 200, 16, 240, 1,               //   620:     decode to VABDLsv8i16 using decoder 240
                                             //   620:    }
  230, 3, 21,                                //   625:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //   628:     switch Inst[6] {
  0, 7,                                      //   631:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   633:      check predicate 35
  OPC_Decode, 219, 16, 238, 1,               //   635:      decode to VABDuv8i8 using decoder 238
                                             //   635:     }
  1, 0,                                      //   640:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   642:      check predicate 35
  OPC_Decode, 214, 16, 239, 1,               //   644:      decode to VABDuv16i8 using decoder 239
                                             //   644:     }
                                             //   644:     } // switch Inst[6]
                                             //   644:    }
  231, 3, 0,                                 //   649:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //   652:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   654:     check Inst[6] == 0x0
  OPC_Decode, 203, 16, 240, 1,               //   658:     decode to VABDLuv8i16 using decoder 240
                                             //   658:    }
                                             //   658:    } // switch Inst[31:23]
                                             //   658:   }
  8, 79,                                     //   663:   case 0x8: {
  OPC_SwitchField, 23, 9,                    //   665:    switch Inst[31:23] {
  228, 3, 21,                                //   668:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //   671:     switch Inst[6] {
  0, 7,                                      //   674:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   676:      check predicate 35
  OPC_Decode, 142, 17, 238, 1,               //   678:      decode to VADDv8i8 using decoder 238
                                             //   678:     }
  1, 0,                                      //   683:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   685:      check predicate 35
  OPC_Decode, 135, 17, 239, 1,               //   687:      decode to VADDv16i8 using decoder 239
                                             //   687:     }
                                             //   687:     } // switch Inst[6]
                                             //   687:    }
  229, 3, 11,                                //   692:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //   695:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   697:     check Inst[6] == 0x0
  OPC_Decode, 146, 23, 245, 1,               //   701:     decode to VMLALsv8i16 using decoder 245
                                             //   701:    }
  230, 3, 21,                                //   706:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //   709:     switch Inst[6] {
  0, 7,                                      //   712:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   714:      check predicate 35
  OPC_Decode, 224, 30, 238, 1,               //   716:      decode to VSUBv8i8 using decoder 238
                                             //   716:     }
  1, 0,                                      //   721:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   723:      check predicate 35
  OPC_Decode, 217, 30, 239, 1,               //   725:      decode to VSUBv16i8 using decoder 239
                                             //   725:     }
                                             //   725:     } // switch Inst[6]
                                             //   725:    }
  231, 3, 0,                                 //   730:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //   733:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   735:     check Inst[6] == 0x0
  OPC_Decode, 149, 23, 245, 1,               //   739:     decode to VMLALuv8i16 using decoder 245
                                             //   739:    }
                                             //   739:    } // switch Inst[31:23]
                                             //   739:   }
  9, 53,                                     //   744:   case 0x9: {
  OPC_SwitchField, 6, 1,                     //   746:    switch Inst[6] {
  0, 23,                                     //   749:    case 0x0: {
  OPC_SwitchField, 23, 9,                    //   751:     switch Inst[31:23] {
  228, 3, 7,                                 //   754:     case 0x1e4: {
  OPC_CheckPredicate, 35,                    //   757:      check predicate 35
  OPC_Decode, 168, 23, 246, 1,               //   759:      decode to VMLAv8i8 using decoder 246
                                             //   759:     }
  230, 3, 0,                                 //   764:     case 0x1e6: {
  OPC_CheckPredicate, 35,                    //   767:      check predicate 35
  OPC_Decode, 199, 23, 246, 1,               //   769:      decode to VMLSv8i8 using decoder 246
                                             //   769:     }
                                             //   769:     } // switch Inst[31:23]
                                             //   769:    }
  1, 0,                                      //   774:    case 0x1: {
  OPC_SwitchField, 23, 9,                    //   776:     switch Inst[31:23] {
  228, 3, 7,                                 //   779:     case 0x1e4: {
  OPC_CheckPredicate, 35,                    //   782:      check predicate 35
  OPC_Decode, 163, 23, 247, 1,               //   784:      decode to VMLAv16i8 using decoder 247
                                             //   784:     }
  230, 3, 0,                                 //   789:     case 0x1e6: {
  OPC_CheckPredicate, 35,                    //   792:      check predicate 35
  OPC_Decode, 194, 23, 247, 1,               //   794:      decode to VMLSv16i8 using decoder 247
                                             //   794:     }
                                             //   794:     } // switch Inst[31:23]
                                             //   794:    }
                                             //   794:    } // switch Inst[6]
                                             //   794:   }
  10, 59,                                    //   799:   case 0xa: {
  OPC_SwitchField, 23, 9,                    //   801:    switch Inst[31:23] {
  228, 3, 11,                                //   804:    case 0x1e4: {
  OPC_CheckPredicate, 35,                    //   807:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   809:     check Inst[6] == 0x0
  OPC_Decode, 230, 24, 238, 1,               //   813:     decode to VPMAXs8 using decoder 238
                                             //   813:    }
  229, 3, 11,                                //   818:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //   821:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   823:     check Inst[6] == 0x0
  OPC_Decode, 177, 23, 245, 1,               //   827:     decode to VMLSLsv8i16 using decoder 245
                                             //   827:    }
  230, 3, 11,                                //   832:    case 0x1e6: {
  OPC_CheckPredicate, 35,                    //   835:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   837:     check Inst[6] == 0x0
  OPC_Decode, 233, 24, 238, 1,               //   841:     decode to VPMAXu8 using decoder 238
                                             //   841:    }
  231, 3, 0,                                 //   846:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //   849:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   851:     check Inst[6] == 0x0
  OPC_Decode, 180, 23, 245, 1,               //   855:     decode to VMLSLuv8i16 using decoder 245
                                             //   855:    }
                                             //   855:    } // switch Inst[31:23]
                                             //   855:   }
  12, 31,                                    //   860:   case 0xc: {
  OPC_SwitchField, 23, 9,                    //   862:    switch Inst[31:23] {
  229, 3, 11,                                //   865:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //   868:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   870:     check Inst[6] == 0x0
  OPC_Decode, 136, 24, 240, 1,               //   874:     decode to VMULLsv8i16 using decoder 240
                                             //   874:    }
  231, 3, 0,                                 //   879:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //   882:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   884:     check Inst[6] == 0x0
  OPC_Decode, 139, 24, 240, 1,               //   888:     decode to VMULLuv8i16 using decoder 240
                                             //   888:    }
                                             //   888:    } // switch Inst[31:23]
                                             //   888:   }
  13, 42,                                    //   893:   case 0xd: {
  OPC_SwitchField, 6, 1,                     //   895:    switch Inst[6] {
  0, 23,                                     //   898:    case 0x0: {
  OPC_SwitchField, 23, 9,                    //   900:     switch Inst[31:23] {
  228, 3, 7,                                 //   903:     case 0x1e4: {
  OPC_CheckPredicate, 35,                    //   906:      check predicate 35
  OPC_Decode, 131, 17, 238, 1,               //   908:      decode to VADDfd using decoder 238
                                             //   908:     }
  230, 3, 0,                                 //   913:     case 0x1e6: {
  OPC_CheckPredicate, 35,                    //   916:      check predicate 35
  OPC_Decode, 221, 24, 238, 1,               //   918:      decode to VPADDf using decoder 238
                                             //   918:     }
                                             //   918:     } // switch Inst[31:23]
                                             //   918:    }
  1, 0,                                      //   923:    case 0x1: {
  OPC_CheckPredicate, 35,                    //   925:     check predicate 35
  OPC_CheckField, 23, 9, 228, 3,             //   927:     check Inst[31:23] == 0x1e4
  OPC_Decode, 132, 17, 239, 1,               //   932:     decode to VADDfq using decoder 239
                                             //   932:    }
                                             //   932:    } // switch Inst[6]
                                             //   932:   }
  14, 65,                                    //   937:   case 0xe: {
  OPC_SwitchField, 23, 9,                    //   939:    switch Inst[31:23] {
  228, 3, 21,                                //   942:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //   945:     switch Inst[6] {
  0, 7,                                      //   948:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   950:      check predicate 35
  OPC_Decode, 167, 17, 238, 1,               //   952:      decode to VCEQfd using decoder 238
                                             //   952:     }
  1, 0,                                      //   957:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   959:      check predicate 35
  OPC_Decode, 168, 17, 239, 1,               //   961:      decode to VCEQfq using decoder 239
                                             //   961:     }
                                             //   961:     } // switch Inst[6]
                                             //   961:    }
  229, 3, 11,                                //   966:    case 0x1e5: {
  OPC_CheckPredicate, 35,                    //   969:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //   971:     check Inst[6] == 0x0
  OPC_Decode, 129, 24, 240, 1,               //   975:     decode to VMULLp8 using decoder 240
                                             //   975:    }
  230, 3, 0,                                 //   980:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //   983:     switch Inst[6] {
  0, 7,                                      //   986:     case 0x0: {
  OPC_CheckPredicate, 35,                    //   988:      check predicate 35
  OPC_Decode, 187, 17, 238, 1,               //   990:      decode to VCGEfd using decoder 238
                                             //   990:     }
  1, 0,                                      //   995:     case 0x1: {
  OPC_CheckPredicate, 35,                    //   997:      check predicate 35
  OPC_Decode, 188, 17, 239, 1,               //   999:      decode to VCGEfq using decoder 239
                                             //   999:     }
                                             //   999:     } // switch Inst[6]
                                             //   999:    }
                                             //   999:    } // switch Inst[31:23]
                                             //   999:   }
  15, 0,                                     //  1004:   case 0xf: {
  OPC_SwitchField, 6, 1,                     //  1006:    switch Inst[6] {
  0, 23,                                     //  1009:    case 0x0: {
  OPC_SwitchField, 23, 9,                    //  1011:     switch Inst[31:23] {
  228, 3, 7,                                 //  1014:     case 0x1e4: {
  OPC_CheckPredicate, 35,                    //  1017:      check predicate 35
  OPC_Decode, 234, 22, 238, 1,               //  1019:      decode to VMAXfd using decoder 238
                                             //  1019:     }
  230, 3, 0,                                 //  1024:     case 0x1e6: {
  OPC_CheckPredicate, 35,                    //  1027:      check predicate 35
  OPC_Decode, 226, 24, 238, 1,               //  1029:      decode to VPMAXf using decoder 238
                                             //  1029:     }
                                             //  1029:     } // switch Inst[31:23]
                                             //  1029:    }
  1, 0,                                      //  1034:    case 0x1: {
  OPC_CheckPredicate, 35,                    //  1036:     check predicate 35
  OPC_CheckField, 23, 9, 228, 3,             //  1038:     check Inst[31:23] == 0x1e4
  OPC_Decode, 235, 22, 239, 1,               //  1043:     decode to VMAXfq using decoder 239
                                             //  1043:    }
                                             //  1043:    } // switch Inst[6]
                                             //  1043:   }
                                             //  1043:   } // switch Inst[11:8]
                                             //  1043:  }
  1, 149, 11,                                //  1048:  case 0x1: {
  OPC_SwitchField, 8, 4,                     //  1051:   switch Inst[11:8] {
  0, 99,                                     //  1054:   case 0x0: {
  OPC_SwitchField, 23, 9,                    //  1056:    switch Inst[31:23] {
  228, 3, 21,                                //  1059:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  1062:     switch Inst[6] {
  0, 7,                                      //  1065:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1067:      check predicate 35
  OPC_Decode, 202, 19, 238, 1,               //  1069:      decode to VHADDsv4i16 using decoder 238
                                             //  1069:     }
  1, 0,                                      //  1074:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1076:      check predicate 35
  OPC_Decode, 204, 19, 239, 1,               //  1078:      decode to VHADDsv8i16 using decoder 239
                                             //  1078:     }
                                             //  1078:     } // switch Inst[6]
                                             //  1078:    }
  229, 3, 21,                                //  1083:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  1086:     switch Inst[6] {
  0, 7,                                      //  1089:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1091:      check predicate 35
  OPC_Decode, 247, 16, 240, 1,               //  1093:      decode to VADDLsv4i32 using decoder 240
                                             //  1093:     }
  1, 0,                                      //  1098:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1100:      check predicate 35
  OPC_Decode, 160, 23, 248, 1,               //  1102:      decode to VMLAslv4i16 using decoder 248
                                             //  1102:     }
                                             //  1102:     } // switch Inst[6]
                                             //  1102:    }
  230, 3, 21,                                //  1107:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  1110:     switch Inst[6] {
  0, 7,                                      //  1113:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1115:      check predicate 35
  OPC_Decode, 208, 19, 238, 1,               //  1117:      decode to VHADDuv4i16 using decoder 238
                                             //  1117:     }
  1, 0,                                      //  1122:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1124:      check predicate 35
  OPC_Decode, 210, 19, 239, 1,               //  1126:      decode to VHADDuv8i16 using decoder 239
                                             //  1126:     }
                                             //  1126:     } // switch Inst[6]
                                             //  1126:    }
  231, 3, 0,                                 //  1131:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  1134:     switch Inst[6] {
  0, 7,                                      //  1137:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1139:      check predicate 35
  OPC_Decode, 250, 16, 240, 1,               //  1141:      decode to VADDLuv4i32 using decoder 240
                                             //  1141:     }
  1, 0,                                      //  1146:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1148:      check predicate 35
  OPC_Decode, 162, 23, 249, 1,               //  1150:      decode to VMLAslv8i16 using decoder 249
                                             //  1150:     }
                                             //  1150:     } // switch Inst[6]
                                             //  1150:    }
                                             //  1150:    } // switch Inst[31:23]
                                             //  1150:   }
  1, 99,                                     //  1155:   case 0x1: {
  OPC_SwitchField, 23, 9,                    //  1157:    switch Inst[31:23] {
  228, 3, 21,                                //  1160:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  1163:     switch Inst[6] {
  0, 7,                                      //  1166:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1168:      check predicate 35
  OPC_Decode, 184, 26, 238, 1,               //  1170:      decode to VRHADDsv4i16 using decoder 238
                                             //  1170:     }
  1, 0,                                      //  1175:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1177:      check predicate 35
  OPC_Decode, 186, 26, 239, 1,               //  1179:      decode to VRHADDsv8i16 using decoder 239
                                             //  1179:     }
                                             //  1179:     } // switch Inst[6]
                                             //  1179:    }
  229, 3, 21,                                //  1184:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  1187:     switch Inst[6] {
  0, 7,                                      //  1190:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1192:      check predicate 35
  OPC_Decode, 254, 16, 241, 1,               //  1194:      decode to VADDWsv4i32 using decoder 241
                                             //  1194:     }
  1, 0,                                      //  1199:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  1201:      check predicate 36
  OPC_Decode, 157, 23, 248, 1,               //  1203:      decode to VMLAslhd using decoder 248
                                             //  1203:     }
                                             //  1203:     } // switch Inst[6]
                                             //  1203:    }
  230, 3, 21,                                //  1208:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  1211:     switch Inst[6] {
  0, 7,                                      //  1214:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1216:      check predicate 35
  OPC_Decode, 190, 26, 238, 1,               //  1218:      decode to VRHADDuv4i16 using decoder 238
                                             //  1218:     }
  1, 0,                                      //  1223:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1225:      check predicate 35
  OPC_Decode, 192, 26, 239, 1,               //  1227:      decode to VRHADDuv8i16 using decoder 239
                                             //  1227:     }
                                             //  1227:     } // switch Inst[6]
                                             //  1227:    }
  231, 3, 0,                                 //  1232:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  1235:     switch Inst[6] {
  0, 7,                                      //  1238:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1240:      check predicate 35
  OPC_Decode, 129, 17, 241, 1,               //  1242:      decode to VADDWuv4i32 using decoder 241
                                             //  1242:     }
  1, 0,                                      //  1247:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  1249:      check predicate 36
  OPC_Decode, 158, 23, 249, 1,               //  1251:      decode to VMLAslhq using decoder 249
                                             //  1251:     }
                                             //  1251:     } // switch Inst[6]
                                             //  1251:    }
                                             //  1251:    } // switch Inst[31:23]
                                             //  1251:   }
  2, 99,                                     //  1256:   case 0x2: {
  OPC_SwitchField, 23, 9,                    //  1258:    switch Inst[31:23] {
  228, 3, 21,                                //  1261:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  1264:     switch Inst[6] {
  0, 7,                                      //  1267:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1269:      check predicate 35
  OPC_Decode, 214, 19, 238, 1,               //  1271:      decode to VHSUBsv4i16 using decoder 238
                                             //  1271:     }
  1, 0,                                      //  1276:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1278:      check predicate 35
  OPC_Decode, 216, 19, 239, 1,               //  1280:      decode to VHSUBsv8i16 using decoder 239
                                             //  1280:     }
                                             //  1280:     } // switch Inst[6]
                                             //  1280:    }
  229, 3, 21,                                //  1285:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  1288:     switch Inst[6] {
  0, 7,                                      //  1291:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1293:      check predicate 35
  OPC_Decode, 201, 30, 240, 1,               //  1295:      decode to VSUBLsv4i32 using decoder 240
                                             //  1295:     }
  1, 0,                                      //  1300:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1302:      check predicate 35
  OPC_Decode, 141, 23, 250, 1,               //  1304:      decode to VMLALslsv4i16 using decoder 250
                                             //  1304:     }
                                             //  1304:     } // switch Inst[6]
                                             //  1304:    }
  230, 3, 21,                                //  1309:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  1312:     switch Inst[6] {
  0, 7,                                      //  1315:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1317:      check predicate 35
  OPC_Decode, 220, 19, 238, 1,               //  1319:      decode to VHSUBuv4i16 using decoder 238
                                             //  1319:     }
  1, 0,                                      //  1324:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1326:      check predicate 35
  OPC_Decode, 222, 19, 239, 1,               //  1328:      decode to VHSUBuv8i16 using decoder 239
                                             //  1328:     }
                                             //  1328:     } // switch Inst[6]
                                             //  1328:    }
  231, 3, 0,                                 //  1333:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  1336:     switch Inst[6] {
  0, 7,                                      //  1339:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1341:      check predicate 35
  OPC_Decode, 204, 30, 240, 1,               //  1343:      decode to VSUBLuv4i32 using decoder 240
                                             //  1343:     }
  1, 0,                                      //  1348:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1350:      check predicate 35
  OPC_Decode, 143, 23, 250, 1,               //  1352:      decode to VMLALsluv4i16 using decoder 250
                                             //  1352:     }
                                             //  1352:     } // switch Inst[6]
                                             //  1352:    }
                                             //  1352:    } // switch Inst[31:23]
                                             //  1352:   }
  3, 89,                                     //  1357:   case 0x3: {
  OPC_SwitchField, 23, 9,                    //  1359:    switch Inst[31:23] {
  228, 3, 21,                                //  1362:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  1365:     switch Inst[6] {
  0, 7,                                      //  1368:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1370:      check predicate 35
  OPC_Decode, 219, 17, 238, 1,               //  1372:      decode to VCGTsv4i16 using decoder 238
                                             //  1372:     }
  1, 0,                                      //  1377:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1379:      check predicate 35
  OPC_Decode, 221, 17, 239, 1,               //  1381:      decode to VCGTsv8i16 using decoder 239
                                             //  1381:     }
                                             //  1381:     } // switch Inst[6]
                                             //  1381:    }
  229, 3, 21,                                //  1386:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  1389:     switch Inst[6] {
  0, 7,                                      //  1392:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1394:      check predicate 35
  OPC_Decode, 208, 30, 241, 1,               //  1396:      decode to VSUBWsv4i32 using decoder 241
                                             //  1396:     }
  1, 0,                                      //  1401:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1403:      check predicate 35
  OPC_Decode, 137, 25, 250, 1,               //  1405:      decode to VQDMLALslv4i16 using decoder 250
                                             //  1405:     }
                                             //  1405:     } // switch Inst[6]
                                             //  1405:    }
  230, 3, 21,                                //  1410:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  1413:     switch Inst[6] {
  0, 7,                                      //  1416:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1418:      check predicate 35
  OPC_Decode, 225, 17, 238, 1,               //  1420:      decode to VCGTuv4i16 using decoder 238
                                             //  1420:     }
  1, 0,                                      //  1425:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1427:      check predicate 35
  OPC_Decode, 227, 17, 239, 1,               //  1429:      decode to VCGTuv8i16 using decoder 239
                                             //  1429:     }
                                             //  1429:     } // switch Inst[6]
                                             //  1429:    }
  231, 3, 0,                                 //  1434:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //  1437:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //  1439:     check Inst[6] == 0x0
  OPC_Decode, 211, 30, 241, 1,               //  1443:     decode to VSUBWuv4i32 using decoder 241
                                             //  1443:    }
                                             //  1443:    } // switch Inst[31:23]
                                             //  1443:   }
  4, 99,                                     //  1448:   case 0x4: {
  OPC_SwitchField, 23, 9,                    //  1450:    switch Inst[31:23] {
  228, 3, 21,                                //  1453:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  1456:     switch Inst[6] {
  0, 7,                                      //  1459:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1461:      check predicate 35
  OPC_Decode, 217, 27, 242, 1,               //  1463:      decode to VSHLsv4i16 using decoder 242
                                             //  1463:     }
  1, 0,                                      //  1468:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1470:      check predicate 35
  OPC_Decode, 219, 27, 243, 1,               //  1472:      decode to VSHLsv8i16 using decoder 243
                                             //  1472:     }
                                             //  1472:     } // switch Inst[6]
                                             //  1472:    }
  229, 3, 21,                                //  1477:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  1480:     switch Inst[6] {
  0, 7,                                      //  1483:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1485:      check predicate 35
  OPC_Decode, 244, 16, 244, 1,               //  1487:      decode to VADDHNv4i16 using decoder 244
                                             //  1487:     }
  1, 0,                                      //  1492:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1494:      check predicate 35
  OPC_Decode, 191, 23, 248, 1,               //  1496:      decode to VMLSslv4i16 using decoder 248
                                             //  1496:     }
                                             //  1496:     } // switch Inst[6]
                                             //  1496:    }
  230, 3, 21,                                //  1501:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  1504:     switch Inst[6] {
  0, 7,                                      //  1507:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1509:      check predicate 35
  OPC_Decode, 225, 27, 242, 1,               //  1511:      decode to VSHLuv4i16 using decoder 242
                                             //  1511:     }
  1, 0,                                      //  1516:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1518:      check predicate 35
  OPC_Decode, 227, 27, 243, 1,               //  1520:      decode to VSHLuv8i16 using decoder 243
                                             //  1520:     }
                                             //  1520:     } // switch Inst[6]
                                             //  1520:    }
  231, 3, 0,                                 //  1525:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  1528:     switch Inst[6] {
  0, 7,                                      //  1531:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1533:      check predicate 35
  OPC_Decode, 158, 26, 244, 1,               //  1535:      decode to VRADDHNv4i16 using decoder 244
                                             //  1535:     }
  1, 0,                                      //  1540:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1542:      check predicate 35
  OPC_Decode, 193, 23, 249, 1,               //  1544:      decode to VMLSslv8i16 using decoder 249
                                             //  1544:     }
                                             //  1544:     } // switch Inst[6]
                                             //  1544:    }
                                             //  1544:    } // switch Inst[31:23]
                                             //  1544:   }
  5, 99,                                     //  1549:   case 0x5: {
  OPC_SwitchField, 23, 9,                    //  1551:    switch Inst[31:23] {
  228, 3, 21,                                //  1554:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  1557:     switch Inst[6] {
  0, 7,                                      //  1560:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1562:      check predicate 35
  OPC_Decode, 243, 26, 242, 1,               //  1564:      decode to VRSHLsv4i16 using decoder 242
                                             //  1564:     }
  1, 0,                                      //  1569:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1571:      check predicate 35
  OPC_Decode, 245, 26, 243, 1,               //  1573:      decode to VRSHLsv8i16 using decoder 243
                                             //  1573:     }
                                             //  1573:     } // switch Inst[6]
                                             //  1573:    }
  229, 3, 21,                                //  1578:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  1581:     switch Inst[6] {
  0, 7,                                      //  1584:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1586:      check predicate 35
  OPC_Decode, 181, 16, 245, 1,               //  1588:      decode to VABALsv4i32 using decoder 245
                                             //  1588:     }
  1, 0,                                      //  1593:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  1595:      check predicate 36
  OPC_Decode, 188, 23, 248, 1,               //  1597:      decode to VMLSslhd using decoder 248
                                             //  1597:     }
                                             //  1597:     } // switch Inst[6]
                                             //  1597:    }
  230, 3, 21,                                //  1602:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  1605:     switch Inst[6] {
  0, 7,                                      //  1608:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1610:      check predicate 35
  OPC_Decode, 251, 26, 242, 1,               //  1612:      decode to VRSHLuv4i16 using decoder 242
                                             //  1612:     }
  1, 0,                                      //  1617:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1619:      check predicate 35
  OPC_Decode, 253, 26, 243, 1,               //  1621:      decode to VRSHLuv8i16 using decoder 243
                                             //  1621:     }
                                             //  1621:     } // switch Inst[6]
                                             //  1621:    }
  231, 3, 0,                                 //  1626:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  1629:     switch Inst[6] {
  0, 7,                                      //  1632:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1634:      check predicate 35
  OPC_Decode, 184, 16, 245, 1,               //  1636:      decode to VABALuv4i32 using decoder 245
                                             //  1636:     }
  1, 0,                                      //  1641:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  1643:      check predicate 36
  OPC_Decode, 189, 23, 249, 1,               //  1645:      decode to VMLSslhq using decoder 249
                                             //  1645:     }
                                             //  1645:     } // switch Inst[6]
                                             //  1645:    }
                                             //  1645:    } // switch Inst[31:23]
                                             //  1645:   }
  6, 99,                                     //  1650:   case 0x6: {
  OPC_SwitchField, 23, 9,                    //  1652:    switch Inst[31:23] {
  228, 3, 21,                                //  1655:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  1658:     switch Inst[6] {
  0, 7,                                      //  1661:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1663:      check predicate 35
  OPC_Decode, 240, 22, 238, 1,               //  1665:      decode to VMAXsv4i16 using decoder 238
                                             //  1665:     }
  1, 0,                                      //  1670:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1672:      check predicate 35
  OPC_Decode, 242, 22, 239, 1,               //  1674:      decode to VMAXsv8i16 using decoder 239
                                             //  1674:     }
                                             //  1674:     } // switch Inst[6]
                                             //  1674:    }
  229, 3, 21,                                //  1679:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  1682:     switch Inst[6] {
  0, 7,                                      //  1685:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1687:      check predicate 35
  OPC_Decode, 198, 30, 244, 1,               //  1689:      decode to VSUBHNv4i16 using decoder 244
                                             //  1689:     }
  1, 0,                                      //  1694:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1696:      check predicate 35
  OPC_Decode, 172, 23, 250, 1,               //  1698:      decode to VMLSLslsv4i16 using decoder 250
                                             //  1698:     }
                                             //  1698:     } // switch Inst[6]
                                             //  1698:    }
  230, 3, 21,                                //  1703:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  1706:     switch Inst[6] {
  0, 7,                                      //  1709:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1711:      check predicate 35
  OPC_Decode, 246, 22, 238, 1,               //  1713:      decode to VMAXuv4i16 using decoder 238
                                             //  1713:     }
  1, 0,                                      //  1718:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1720:      check predicate 35
  OPC_Decode, 248, 22, 239, 1,               //  1722:      decode to VMAXuv8i16 using decoder 239
                                             //  1722:     }
                                             //  1722:     } // switch Inst[6]
                                             //  1722:    }
  231, 3, 0,                                 //  1727:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  1730:     switch Inst[6] {
  0, 7,                                      //  1733:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1735:      check predicate 35
  OPC_Decode, 173, 27, 244, 1,               //  1737:      decode to VRSUBHNv4i16 using decoder 244
                                             //  1737:     }
  1, 0,                                      //  1742:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1744:      check predicate 35
  OPC_Decode, 174, 23, 250, 1,               //  1746:      decode to VMLSLsluv4i16 using decoder 250
                                             //  1746:     }
                                             //  1746:     } // switch Inst[6]
                                             //  1746:    }
                                             //  1746:    } // switch Inst[31:23]
                                             //  1746:   }
  7, 89,                                     //  1751:   case 0x7: {
  OPC_SwitchField, 23, 9,                    //  1753:    switch Inst[31:23] {
  228, 3, 21,                                //  1756:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  1759:     switch Inst[6] {
  0, 7,                                      //  1762:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1764:      check predicate 35
  OPC_Decode, 210, 16, 238, 1,               //  1766:      decode to VABDsv4i16 using decoder 238
                                             //  1766:     }
  1, 0,                                      //  1771:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1773:      check predicate 35
  OPC_Decode, 212, 16, 239, 1,               //  1775:      decode to VABDsv8i16 using decoder 239
                                             //  1775:     }
                                             //  1775:     } // switch Inst[6]
                                             //  1775:    }
  229, 3, 21,                                //  1780:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  1783:     switch Inst[6] {
  0, 7,                                      //  1786:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1788:      check predicate 35
  OPC_Decode, 199, 16, 240, 1,               //  1790:      decode to VABDLsv4i32 using decoder 240
                                             //  1790:     }
  1, 0,                                      //  1795:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1797:      check predicate 35
  OPC_Decode, 141, 25, 250, 1,               //  1799:      decode to VQDMLSLslv4i16 using decoder 250
                                             //  1799:     }
                                             //  1799:     } // switch Inst[6]
                                             //  1799:    }
  230, 3, 21,                                //  1804:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  1807:     switch Inst[6] {
  0, 7,                                      //  1810:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1812:      check predicate 35
  OPC_Decode, 216, 16, 238, 1,               //  1814:      decode to VABDuv4i16 using decoder 238
                                             //  1814:     }
  1, 0,                                      //  1819:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1821:      check predicate 35
  OPC_Decode, 218, 16, 239, 1,               //  1823:      decode to VABDuv8i16 using decoder 239
                                             //  1823:     }
                                             //  1823:     } // switch Inst[6]
                                             //  1823:    }
  231, 3, 0,                                 //  1828:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //  1831:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //  1833:     check Inst[6] == 0x0
  OPC_Decode, 202, 16, 240, 1,               //  1837:     decode to VABDLuv4i32 using decoder 240
                                             //  1837:    }
                                             //  1837:    } // switch Inst[31:23]
                                             //  1837:   }
  8, 99,                                     //  1842:   case 0x8: {
  OPC_SwitchField, 23, 9,                    //  1844:    switch Inst[31:23] {
  228, 3, 21,                                //  1847:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  1850:     switch Inst[6] {
  0, 7,                                      //  1853:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1855:      check predicate 35
  OPC_Decode, 139, 17, 238, 1,               //  1857:      decode to VADDv4i16 using decoder 238
                                             //  1857:     }
  1, 0,                                      //  1862:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1864:      check predicate 35
  OPC_Decode, 141, 17, 239, 1,               //  1866:      decode to VADDv8i16 using decoder 239
                                             //  1866:     }
                                             //  1866:     } // switch Inst[6]
                                             //  1866:    }
  229, 3, 21,                                //  1871:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  1874:     switch Inst[6] {
  0, 7,                                      //  1877:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1879:      check predicate 35
  OPC_Decode, 145, 23, 245, 1,               //  1881:      decode to VMLALsv4i32 using decoder 245
                                             //  1881:     }
  1, 0,                                      //  1886:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1888:      check predicate 35
  OPC_Decode, 152, 24, 251, 1,               //  1890:      decode to VMULslv4i16 using decoder 251
                                             //  1890:     }
                                             //  1890:     } // switch Inst[6]
                                             //  1890:    }
  230, 3, 21,                                //  1895:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  1898:     switch Inst[6] {
  0, 7,                                      //  1901:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1903:      check predicate 35
  OPC_Decode, 221, 30, 238, 1,               //  1905:      decode to VSUBv4i16 using decoder 238
                                             //  1905:     }
  1, 0,                                      //  1910:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1912:      check predicate 35
  OPC_Decode, 223, 30, 239, 1,               //  1914:      decode to VSUBv8i16 using decoder 239
                                             //  1914:     }
                                             //  1914:     } // switch Inst[6]
                                             //  1914:    }
  231, 3, 0,                                 //  1919:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  1922:     switch Inst[6] {
  0, 7,                                      //  1925:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1927:      check predicate 35
  OPC_Decode, 148, 23, 245, 1,               //  1929:      decode to VMLALuv4i32 using decoder 245
                                             //  1929:     }
  1, 0,                                      //  1934:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1936:      check predicate 35
  OPC_Decode, 154, 24, 252, 1,               //  1938:      decode to VMULslv8i16 using decoder 252
                                             //  1938:     }
                                             //  1938:     } // switch Inst[6]
                                             //  1938:    }
                                             //  1938:    } // switch Inst[31:23]
                                             //  1938:   }
  9, 89,                                     //  1943:   case 0x9: {
  OPC_SwitchField, 23, 9,                    //  1945:    switch Inst[31:23] {
  228, 3, 21,                                //  1948:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  1951:     switch Inst[6] {
  0, 7,                                      //  1954:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1956:      check predicate 35
  OPC_Decode, 165, 23, 246, 1,               //  1958:      decode to VMLAv4i16 using decoder 246
                                             //  1958:     }
  1, 0,                                      //  1963:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  1965:      check predicate 35
  OPC_Decode, 167, 23, 247, 1,               //  1967:      decode to VMLAv8i16 using decoder 247
                                             //  1967:     }
                                             //  1967:     } // switch Inst[6]
                                             //  1967:    }
  229, 3, 21,                                //  1972:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  1975:     switch Inst[6] {
  0, 7,                                      //  1978:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  1980:      check predicate 35
  OPC_Decode, 139, 25, 245, 1,               //  1982:      decode to VQDMLALv4i32 using decoder 245
                                             //  1982:     }
  1, 0,                                      //  1987:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  1989:      check predicate 36
  OPC_Decode, 149, 24, 251, 1,               //  1991:      decode to VMULslhd using decoder 251
                                             //  1991:     }
                                             //  1991:     } // switch Inst[6]
                                             //  1991:    }
  230, 3, 21,                                //  1996:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  1999:     switch Inst[6] {
  0, 7,                                      //  2002:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2004:      check predicate 35
  OPC_Decode, 196, 23, 246, 1,               //  2006:      decode to VMLSv4i16 using decoder 246
                                             //  2006:     }
  1, 0,                                      //  2011:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2013:      check predicate 35
  OPC_Decode, 198, 23, 247, 1,               //  2015:      decode to VMLSv8i16 using decoder 247
                                             //  2015:     }
                                             //  2015:     } // switch Inst[6]
                                             //  2015:    }
  231, 3, 0,                                 //  2020:    case 0x1e7: {
  OPC_CheckPredicate, 36,                    //  2023:     check predicate 36
  OPC_CheckField, 6, 1, 1,                   //  2025:     check Inst[6] == 0x1
  OPC_Decode, 150, 24, 252, 1,               //  2029:     decode to VMULslhq using decoder 252
                                             //  2029:    }
                                             //  2029:    } // switch Inst[31:23]
                                             //  2029:   }
  10, 79,                                    //  2034:   case 0xa: {
  OPC_SwitchField, 23, 9,                    //  2036:    switch Inst[31:23] {
  228, 3, 11,                                //  2039:    case 0x1e4: {
  OPC_CheckPredicate, 35,                    //  2042:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //  2044:     check Inst[6] == 0x0
  OPC_Decode, 228, 24, 238, 1,               //  2048:     decode to VPMAXs16 using decoder 238
                                             //  2048:    }
  229, 3, 21,                                //  2053:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  2056:     switch Inst[6] {
  0, 7,                                      //  2059:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2061:      check predicate 35
  OPC_Decode, 176, 23, 245, 1,               //  2063:      decode to VMLSLsv4i32 using decoder 245
                                             //  2063:     }
  1, 0,                                      //  2068:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2070:      check predicate 35
  OPC_Decode, 131, 24, 253, 1,               //  2072:      decode to VMULLslsv4i16 using decoder 253
                                             //  2072:     }
                                             //  2072:     } // switch Inst[6]
                                             //  2072:    }
  230, 3, 11,                                //  2077:    case 0x1e6: {
  OPC_CheckPredicate, 35,                    //  2080:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //  2082:     check Inst[6] == 0x0
  OPC_Decode, 231, 24, 238, 1,               //  2086:     decode to VPMAXu16 using decoder 238
                                             //  2086:    }
  231, 3, 0,                                 //  2091:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  2094:     switch Inst[6] {
  0, 7,                                      //  2097:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2099:      check predicate 35
  OPC_Decode, 179, 23, 245, 1,               //  2101:      decode to VMLSLuv4i32 using decoder 245
                                             //  2101:     }
  1, 0,                                      //  2106:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2108:      check predicate 35
  OPC_Decode, 133, 24, 253, 1,               //  2110:      decode to VMULLsluv4i16 using decoder 253
                                             //  2110:     }
                                             //  2110:     } // switch Inst[6]
                                             //  2110:    }
                                             //  2110:    } // switch Inst[31:23]
                                             //  2110:   }
  11, 75,                                    //  2115:   case 0xb: {
  OPC_SwitchField, 23, 9,                    //  2117:    switch Inst[31:23] {
  228, 3, 21,                                //  2120:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  2123:     switch Inst[6] {
  0, 7,                                      //  2126:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2128:      check predicate 35
  OPC_Decode, 149, 25, 238, 1,               //  2130:      decode to VQDMULHv4i16 using decoder 238
                                             //  2130:     }
  1, 0,                                      //  2135:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2137:      check predicate 35
  OPC_Decode, 151, 25, 239, 1,               //  2139:      decode to VQDMULHv8i16 using decoder 239
                                             //  2139:     }
                                             //  2139:     } // switch Inst[6]
                                             //  2139:    }
  229, 3, 21,                                //  2144:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  2147:     switch Inst[6] {
  0, 7,                                      //  2150:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2152:      check predicate 35
  OPC_Decode, 143, 25, 245, 1,               //  2154:      decode to VQDMLSLv4i32 using decoder 245
                                             //  2154:     }
  1, 0,                                      //  2159:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2161:      check predicate 35
  OPC_Decode, 153, 25, 253, 1,               //  2163:      decode to VQDMULLslv4i16 using decoder 253
                                             //  2163:     }
                                             //  2163:     } // switch Inst[6]
                                             //  2163:    }
  230, 3, 0,                                 //  2168:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  2171:     switch Inst[6] {
  0, 7,                                      //  2174:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2176:      check predicate 35
  OPC_Decode, 192, 25, 238, 1,               //  2178:      decode to VQRDMULHv4i16 using decoder 238
                                             //  2178:     }
  1, 0,                                      //  2183:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2185:      check predicate 35
  OPC_Decode, 194, 25, 239, 1,               //  2187:      decode to VQRDMULHv8i16 using decoder 239
                                             //  2187:     }
                                             //  2187:     } // switch Inst[6]
                                             //  2187:    }
                                             //  2187:    } // switch Inst[31:23]
                                             //  2187:   }
  12, 53,                                    //  2192:   case 0xc: {
  OPC_SwitchField, 6, 1,                     //  2194:    switch Inst[6] {
  0, 23,                                     //  2197:    case 0x0: {
  OPC_SwitchField, 23, 9,                    //  2199:     switch Inst[31:23] {
  229, 3, 7,                                 //  2202:     case 0x1e5: {
  OPC_CheckPredicate, 35,                    //  2205:      check predicate 35
  OPC_Decode, 135, 24, 240, 1,               //  2207:      decode to VMULLsv4i32 using decoder 240
                                             //  2207:     }
  231, 3, 0,                                 //  2212:     case 0x1e7: {
  OPC_CheckPredicate, 35,                    //  2215:      check predicate 35
  OPC_Decode, 138, 24, 240, 1,               //  2217:      decode to VMULLuv4i32 using decoder 240
                                             //  2217:     }
                                             //  2217:     } // switch Inst[31:23]
                                             //  2217:    }
  1, 0,                                      //  2222:    case 0x1: {
  OPC_SwitchField, 23, 9,                    //  2224:     switch Inst[31:23] {
  229, 3, 7,                                 //  2227:     case 0x1e5: {
  OPC_CheckPredicate, 35,                    //  2230:      check predicate 35
  OPC_Decode, 145, 25, 251, 1,               //  2232:      decode to VQDMULHslv4i16 using decoder 251
                                             //  2232:     }
  231, 3, 0,                                 //  2237:     case 0x1e7: {
  OPC_CheckPredicate, 35,                    //  2240:      check predicate 35
  OPC_Decode, 147, 25, 252, 1,               //  2242:      decode to VQDMULHslv8i16 using decoder 252
                                             //  2242:     }
                                             //  2242:     } // switch Inst[31:23]
                                             //  2242:    }
                                             //  2242:    } // switch Inst[6]
                                             //  2242:   }
  13, 79,                                    //  2247:   case 0xd: {
  OPC_SwitchField, 23, 9,                    //  2249:    switch Inst[31:23] {
  228, 3, 21,                                //  2252:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  2255:     switch Inst[6] {
  0, 7,                                      //  2258:     case 0x0: {
  OPC_CheckPredicate, 36,                    //  2260:      check predicate 36
  OPC_Decode, 133, 17, 238, 1,               //  2262:      decode to VADDhd using decoder 238
                                             //  2262:     }
  1, 0,                                      //  2267:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  2269:      check predicate 36
  OPC_Decode, 134, 17, 239, 1,               //  2271:      decode to VADDhq using decoder 239
                                             //  2271:     }
                                             //  2271:     } // switch Inst[6]
                                             //  2271:    }
  229, 3, 21,                                //  2276:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  2279:     switch Inst[6] {
  0, 7,                                      //  2282:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2284:      check predicate 35
  OPC_Decode, 155, 25, 240, 1,               //  2286:      decode to VQDMULLv4i32 using decoder 240
                                             //  2286:     }
  1, 0,                                      //  2291:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2293:      check predicate 35
  OPC_Decode, 188, 25, 251, 1,               //  2295:      decode to VQRDMULHslv4i16 using decoder 251
                                             //  2295:     }
                                             //  2295:     } // switch Inst[6]
                                             //  2295:    }
  230, 3, 11,                                //  2300:    case 0x1e6: {
  OPC_CheckPredicate, 36,                    //  2303:     check predicate 36
  OPC_CheckField, 6, 1, 0,                   //  2305:     check Inst[6] == 0x0
  OPC_Decode, 222, 24, 238, 1,               //  2309:     decode to VPADDh using decoder 238
                                             //  2309:    }
  231, 3, 0,                                 //  2314:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //  2317:     check predicate 35
  OPC_CheckField, 6, 1, 1,                   //  2319:     check Inst[6] == 0x1
  OPC_Decode, 190, 25, 252, 1,               //  2323:     decode to VQRDMULHslv8i16 using decoder 252
                                             //  2323:    }
                                             //  2323:    } // switch Inst[31:23]
                                             //  2323:   }
  14, 79,                                    //  2328:   case 0xe: {
  OPC_SwitchField, 23, 9,                    //  2330:    switch Inst[31:23] {
  228, 3, 21,                                //  2333:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  2336:     switch Inst[6] {
  0, 7,                                      //  2339:     case 0x0: {
  OPC_CheckPredicate, 36,                    //  2341:      check predicate 36
  OPC_Decode, 169, 17, 238, 1,               //  2343:      decode to VCEQhd using decoder 238
                                             //  2343:     }
  1, 0,                                      //  2348:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  2350:      check predicate 36
  OPC_Decode, 170, 17, 239, 1,               //  2352:      decode to VCEQhq using decoder 239
                                             //  2352:     }
                                             //  2352:     } // switch Inst[6]
                                             //  2352:    }
  229, 3, 11,                                //  2357:    case 0x1e5: {
  OPC_CheckPredicate, 37,                    //  2360:     check predicate 37
  OPC_CheckField, 6, 1, 1,                   //  2362:     check Inst[6] == 0x1
  OPC_Decode, 172, 25, 248, 1,               //  2366:     decode to VQRDMLAHslv4i16 using decoder 248
                                             //  2366:    }
  230, 3, 21,                                //  2371:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  2374:     switch Inst[6] {
  0, 7,                                      //  2377:     case 0x0: {
  OPC_CheckPredicate, 36,                    //  2379:      check predicate 36
  OPC_Decode, 189, 17, 238, 1,               //  2381:      decode to VCGEhd using decoder 238
                                             //  2381:     }
  1, 0,                                      //  2386:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  2388:      check predicate 36
  OPC_Decode, 190, 17, 239, 1,               //  2390:      decode to VCGEhq using decoder 239
                                             //  2390:     }
                                             //  2390:     } // switch Inst[6]
                                             //  2390:    }
  231, 3, 0,                                 //  2395:    case 0x1e7: {
  OPC_CheckPredicate, 37,                    //  2398:     check predicate 37
  OPC_CheckField, 6, 1, 1,                   //  2400:     check Inst[6] == 0x1
  OPC_Decode, 174, 25, 249, 1,               //  2404:     decode to VQRDMLAHslv8i16 using decoder 249
                                             //  2404:    }
                                             //  2404:    } // switch Inst[31:23]
                                             //  2404:   }
  15, 0,                                     //  2409:   case 0xf: {
  OPC_SwitchField, 23, 9,                    //  2411:    switch Inst[31:23] {
  228, 3, 21,                                //  2414:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  2417:     switch Inst[6] {
  0, 7,                                      //  2420:     case 0x0: {
  OPC_CheckPredicate, 36,                    //  2422:      check predicate 36
  OPC_Decode, 236, 22, 238, 1,               //  2424:      decode to VMAXhd using decoder 238
                                             //  2424:     }
  1, 0,                                      //  2429:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  2431:      check predicate 36
  OPC_Decode, 237, 22, 239, 1,               //  2433:      decode to VMAXhq using decoder 239
                                             //  2433:     }
                                             //  2433:     } // switch Inst[6]
                                             //  2433:    }
  229, 3, 11,                                //  2438:    case 0x1e5: {
  OPC_CheckPredicate, 37,                    //  2441:     check predicate 37
  OPC_CheckField, 6, 1, 1,                   //  2443:     check Inst[6] == 0x1
  OPC_Decode, 180, 25, 248, 1,               //  2447:     decode to VQRDMLSHslv4i16 using decoder 248
                                             //  2447:    }
  230, 3, 11,                                //  2452:    case 0x1e6: {
  OPC_CheckPredicate, 36,                    //  2455:     check predicate 36
  OPC_CheckField, 6, 1, 0,                   //  2457:     check Inst[6] == 0x0
  OPC_Decode, 227, 24, 238, 1,               //  2461:     decode to VPMAXh using decoder 238
                                             //  2461:    }
  231, 3, 0,                                 //  2466:    case 0x1e7: {
  OPC_CheckPredicate, 37,                    //  2469:     check predicate 37
  OPC_CheckField, 6, 1, 1,                   //  2471:     check Inst[6] == 0x1
  OPC_Decode, 182, 25, 249, 1,               //  2475:     decode to VQRDMLSHslv8i16 using decoder 249
                                             //  2475:    }
                                             //  2475:    } // switch Inst[31:23]
                                             //  2475:   }
                                             //  2475:   } // switch Inst[11:8]
                                             //  2475:  }
  2, 145, 11,                                //  2480:  case 0x2: {
  OPC_SwitchField, 8, 4,                     //  2483:   switch Inst[11:8] {
  0, 99,                                     //  2486:   case 0x0: {
  OPC_SwitchField, 23, 9,                    //  2488:    switch Inst[31:23] {
  228, 3, 21,                                //  2491:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  2494:     switch Inst[6] {
  0, 7,                                      //  2497:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2499:      check predicate 35
  OPC_Decode, 201, 19, 238, 1,               //  2501:      decode to VHADDsv2i32 using decoder 238
                                             //  2501:     }
  1, 0,                                      //  2506:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2508:      check predicate 35
  OPC_Decode, 203, 19, 239, 1,               //  2510:      decode to VHADDsv4i32 using decoder 239
                                             //  2510:     }
                                             //  2510:     } // switch Inst[6]
                                             //  2510:    }
  229, 3, 21,                                //  2515:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  2518:     switch Inst[6] {
  0, 7,                                      //  2521:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2523:      check predicate 35
  OPC_Decode, 246, 16, 240, 1,               //  2525:      decode to VADDLsv2i64 using decoder 240
                                             //  2525:     }
  1, 0,                                      //  2530:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2532:      check predicate 35
  OPC_Decode, 159, 23, 254, 1,               //  2534:      decode to VMLAslv2i32 using decoder 254
                                             //  2534:     }
                                             //  2534:     } // switch Inst[6]
                                             //  2534:    }
  230, 3, 21,                                //  2539:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  2542:     switch Inst[6] {
  0, 7,                                      //  2545:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2547:      check predicate 35
  OPC_Decode, 207, 19, 238, 1,               //  2549:      decode to VHADDuv2i32 using decoder 238
                                             //  2549:     }
  1, 0,                                      //  2554:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2556:      check predicate 35
  OPC_Decode, 209, 19, 239, 1,               //  2558:      decode to VHADDuv4i32 using decoder 239
                                             //  2558:     }
                                             //  2558:     } // switch Inst[6]
                                             //  2558:    }
  231, 3, 0,                                 //  2563:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  2566:     switch Inst[6] {
  0, 7,                                      //  2569:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2571:      check predicate 35
  OPC_Decode, 249, 16, 240, 1,               //  2573:      decode to VADDLuv2i64 using decoder 240
                                             //  2573:     }
  1, 0,                                      //  2578:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2580:      check predicate 35
  OPC_Decode, 161, 23, 255, 1,               //  2582:      decode to VMLAslv4i32 using decoder 255
                                             //  2582:     }
                                             //  2582:     } // switch Inst[6]
                                             //  2582:    }
                                             //  2582:    } // switch Inst[31:23]
                                             //  2582:   }
  1, 99,                                     //  2587:   case 0x1: {
  OPC_SwitchField, 23, 9,                    //  2589:    switch Inst[31:23] {
  228, 3, 21,                                //  2592:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  2595:     switch Inst[6] {
  0, 7,                                      //  2598:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2600:      check predicate 35
  OPC_Decode, 183, 26, 238, 1,               //  2602:      decode to VRHADDsv2i32 using decoder 238
                                             //  2602:     }
  1, 0,                                      //  2607:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2609:      check predicate 35
  OPC_Decode, 185, 26, 239, 1,               //  2611:      decode to VRHADDsv4i32 using decoder 239
                                             //  2611:     }
                                             //  2611:     } // switch Inst[6]
                                             //  2611:    }
  229, 3, 21,                                //  2616:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  2619:     switch Inst[6] {
  0, 7,                                      //  2622:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2624:      check predicate 35
  OPC_Decode, 253, 16, 241, 1,               //  2626:      decode to VADDWsv2i64 using decoder 241
                                             //  2626:     }
  1, 0,                                      //  2631:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2633:      check predicate 35
  OPC_Decode, 155, 23, 254, 1,               //  2635:      decode to VMLAslfd using decoder 254
                                             //  2635:     }
                                             //  2635:     } // switch Inst[6]
                                             //  2635:    }
  230, 3, 21,                                //  2640:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  2643:     switch Inst[6] {
  0, 7,                                      //  2646:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2648:      check predicate 35
  OPC_Decode, 189, 26, 238, 1,               //  2650:      decode to VRHADDuv2i32 using decoder 238
                                             //  2650:     }
  1, 0,                                      //  2655:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2657:      check predicate 35
  OPC_Decode, 191, 26, 239, 1,               //  2659:      decode to VRHADDuv4i32 using decoder 239
                                             //  2659:     }
                                             //  2659:     } // switch Inst[6]
                                             //  2659:    }
  231, 3, 0,                                 //  2664:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  2667:     switch Inst[6] {
  0, 7,                                      //  2670:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2672:      check predicate 35
  OPC_Decode, 128, 17, 241, 1,               //  2674:      decode to VADDWuv2i64 using decoder 241
                                             //  2674:     }
  1, 0,                                      //  2679:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2681:      check predicate 35
  OPC_Decode, 156, 23, 255, 1,               //  2683:      decode to VMLAslfq using decoder 255
                                             //  2683:     }
                                             //  2683:     } // switch Inst[6]
                                             //  2683:    }
                                             //  2683:    } // switch Inst[31:23]
                                             //  2683:   }
  2, 99,                                     //  2688:   case 0x2: {
  OPC_SwitchField, 23, 9,                    //  2690:    switch Inst[31:23] {
  228, 3, 21,                                //  2693:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  2696:     switch Inst[6] {
  0, 7,                                      //  2699:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2701:      check predicate 35
  OPC_Decode, 213, 19, 238, 1,               //  2703:      decode to VHSUBsv2i32 using decoder 238
                                             //  2703:     }
  1, 0,                                      //  2708:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2710:      check predicate 35
  OPC_Decode, 215, 19, 239, 1,               //  2712:      decode to VHSUBsv4i32 using decoder 239
                                             //  2712:     }
                                             //  2712:     } // switch Inst[6]
                                             //  2712:    }
  229, 3, 21,                                //  2717:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  2720:     switch Inst[6] {
  0, 7,                                      //  2723:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2725:      check predicate 35
  OPC_Decode, 200, 30, 240, 1,               //  2727:      decode to VSUBLsv2i64 using decoder 240
                                             //  2727:     }
  1, 0,                                      //  2732:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2734:      check predicate 35
  OPC_Decode, 140, 23, 128, 2,               //  2736:      decode to VMLALslsv2i32 using decoder 256
                                             //  2736:     }
                                             //  2736:     } // switch Inst[6]
                                             //  2736:    }
  230, 3, 21,                                //  2741:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  2744:     switch Inst[6] {
  0, 7,                                      //  2747:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2749:      check predicate 35
  OPC_Decode, 219, 19, 238, 1,               //  2751:      decode to VHSUBuv2i32 using decoder 238
                                             //  2751:     }
  1, 0,                                      //  2756:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2758:      check predicate 35
  OPC_Decode, 221, 19, 239, 1,               //  2760:      decode to VHSUBuv4i32 using decoder 239
                                             //  2760:     }
                                             //  2760:     } // switch Inst[6]
                                             //  2760:    }
  231, 3, 0,                                 //  2765:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  2768:     switch Inst[6] {
  0, 7,                                      //  2771:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2773:      check predicate 35
  OPC_Decode, 203, 30, 240, 1,               //  2775:      decode to VSUBLuv2i64 using decoder 240
                                             //  2775:     }
  1, 0,                                      //  2780:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2782:      check predicate 35
  OPC_Decode, 142, 23, 128, 2,               //  2784:      decode to VMLALsluv2i32 using decoder 256
                                             //  2784:     }
                                             //  2784:     } // switch Inst[6]
                                             //  2784:    }
                                             //  2784:    } // switch Inst[31:23]
                                             //  2784:   }
  3, 89,                                     //  2789:   case 0x3: {
  OPC_SwitchField, 23, 9,                    //  2791:    switch Inst[31:23] {
  228, 3, 21,                                //  2794:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  2797:     switch Inst[6] {
  0, 7,                                      //  2800:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2802:      check predicate 35
  OPC_Decode, 218, 17, 238, 1,               //  2804:      decode to VCGTsv2i32 using decoder 238
                                             //  2804:     }
  1, 0,                                      //  2809:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2811:      check predicate 35
  OPC_Decode, 220, 17, 239, 1,               //  2813:      decode to VCGTsv4i32 using decoder 239
                                             //  2813:     }
                                             //  2813:     } // switch Inst[6]
                                             //  2813:    }
  229, 3, 21,                                //  2818:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  2821:     switch Inst[6] {
  0, 7,                                      //  2824:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2826:      check predicate 35
  OPC_Decode, 207, 30, 241, 1,               //  2828:      decode to VSUBWsv2i64 using decoder 241
                                             //  2828:     }
  1, 0,                                      //  2833:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2835:      check predicate 35
  OPC_Decode, 136, 25, 128, 2,               //  2837:      decode to VQDMLALslv2i32 using decoder 256
                                             //  2837:     }
                                             //  2837:     } // switch Inst[6]
                                             //  2837:    }
  230, 3, 21,                                //  2842:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  2845:     switch Inst[6] {
  0, 7,                                      //  2848:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2850:      check predicate 35
  OPC_Decode, 224, 17, 238, 1,               //  2852:      decode to VCGTuv2i32 using decoder 238
                                             //  2852:     }
  1, 0,                                      //  2857:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2859:      check predicate 35
  OPC_Decode, 226, 17, 239, 1,               //  2861:      decode to VCGTuv4i32 using decoder 239
                                             //  2861:     }
                                             //  2861:     } // switch Inst[6]
                                             //  2861:    }
  231, 3, 0,                                 //  2866:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //  2869:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //  2871:     check Inst[6] == 0x0
  OPC_Decode, 210, 30, 241, 1,               //  2875:     decode to VSUBWuv2i64 using decoder 241
                                             //  2875:    }
                                             //  2875:    } // switch Inst[31:23]
                                             //  2875:   }
  4, 99,                                     //  2880:   case 0x4: {
  OPC_SwitchField, 23, 9,                    //  2882:    switch Inst[31:23] {
  228, 3, 21,                                //  2885:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  2888:     switch Inst[6] {
  0, 7,                                      //  2891:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2893:      check predicate 35
  OPC_Decode, 215, 27, 242, 1,               //  2895:      decode to VSHLsv2i32 using decoder 242
                                             //  2895:     }
  1, 0,                                      //  2900:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2902:      check predicate 35
  OPC_Decode, 218, 27, 243, 1,               //  2904:      decode to VSHLsv4i32 using decoder 243
                                             //  2904:     }
                                             //  2904:     } // switch Inst[6]
                                             //  2904:    }
  229, 3, 21,                                //  2909:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  2912:     switch Inst[6] {
  0, 7,                                      //  2915:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2917:      check predicate 35
  OPC_Decode, 243, 16, 244, 1,               //  2919:      decode to VADDHNv2i32 using decoder 244
                                             //  2919:     }
  1, 0,                                      //  2924:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2926:      check predicate 35
  OPC_Decode, 190, 23, 254, 1,               //  2928:      decode to VMLSslv2i32 using decoder 254
                                             //  2928:     }
                                             //  2928:     } // switch Inst[6]
                                             //  2928:    }
  230, 3, 21,                                //  2933:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  2936:     switch Inst[6] {
  0, 7,                                      //  2939:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2941:      check predicate 35
  OPC_Decode, 223, 27, 242, 1,               //  2943:      decode to VSHLuv2i32 using decoder 242
                                             //  2943:     }
  1, 0,                                      //  2948:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2950:      check predicate 35
  OPC_Decode, 226, 27, 243, 1,               //  2952:      decode to VSHLuv4i32 using decoder 243
                                             //  2952:     }
                                             //  2952:     } // switch Inst[6]
                                             //  2952:    }
  231, 3, 0,                                 //  2957:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  2960:     switch Inst[6] {
  0, 7,                                      //  2963:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2965:      check predicate 35
  OPC_Decode, 157, 26, 244, 1,               //  2967:      decode to VRADDHNv2i32 using decoder 244
                                             //  2967:     }
  1, 0,                                      //  2972:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  2974:      check predicate 35
  OPC_Decode, 192, 23, 255, 1,               //  2976:      decode to VMLSslv4i32 using decoder 255
                                             //  2976:     }
                                             //  2976:     } // switch Inst[6]
                                             //  2976:    }
                                             //  2976:    } // switch Inst[31:23]
                                             //  2976:   }
  5, 99,                                     //  2981:   case 0x5: {
  OPC_SwitchField, 23, 9,                    //  2983:    switch Inst[31:23] {
  228, 3, 21,                                //  2986:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  2989:     switch Inst[6] {
  0, 7,                                      //  2992:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  2994:      check predicate 35
  OPC_Decode, 241, 26, 242, 1,               //  2996:      decode to VRSHLsv2i32 using decoder 242
                                             //  2996:     }
  1, 0,                                      //  3001:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3003:      check predicate 35
  OPC_Decode, 244, 26, 243, 1,               //  3005:      decode to VRSHLsv4i32 using decoder 243
                                             //  3005:     }
                                             //  3005:     } // switch Inst[6]
                                             //  3005:    }
  229, 3, 21,                                //  3010:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  3013:     switch Inst[6] {
  0, 7,                                      //  3016:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3018:      check predicate 35
  OPC_Decode, 180, 16, 245, 1,               //  3020:      decode to VABALsv2i64 using decoder 245
                                             //  3020:     }
  1, 0,                                      //  3025:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3027:      check predicate 35
  OPC_Decode, 186, 23, 254, 1,               //  3029:      decode to VMLSslfd using decoder 254
                                             //  3029:     }
                                             //  3029:     } // switch Inst[6]
                                             //  3029:    }
  230, 3, 21,                                //  3034:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  3037:     switch Inst[6] {
  0, 7,                                      //  3040:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3042:      check predicate 35
  OPC_Decode, 249, 26, 242, 1,               //  3044:      decode to VRSHLuv2i32 using decoder 242
                                             //  3044:     }
  1, 0,                                      //  3049:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3051:      check predicate 35
  OPC_Decode, 252, 26, 243, 1,               //  3053:      decode to VRSHLuv4i32 using decoder 243
                                             //  3053:     }
                                             //  3053:     } // switch Inst[6]
                                             //  3053:    }
  231, 3, 0,                                 //  3058:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  3061:     switch Inst[6] {
  0, 7,                                      //  3064:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3066:      check predicate 35
  OPC_Decode, 183, 16, 245, 1,               //  3068:      decode to VABALuv2i64 using decoder 245
                                             //  3068:     }
  1, 0,                                      //  3073:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3075:      check predicate 35
  OPC_Decode, 187, 23, 255, 1,               //  3077:      decode to VMLSslfq using decoder 255
                                             //  3077:     }
                                             //  3077:     } // switch Inst[6]
                                             //  3077:    }
                                             //  3077:    } // switch Inst[31:23]
                                             //  3077:   }
  6, 99,                                     //  3082:   case 0x6: {
  OPC_SwitchField, 23, 9,                    //  3084:    switch Inst[31:23] {
  228, 3, 21,                                //  3087:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  3090:     switch Inst[6] {
  0, 7,                                      //  3093:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3095:      check predicate 35
  OPC_Decode, 239, 22, 238, 1,               //  3097:      decode to VMAXsv2i32 using decoder 238
                                             //  3097:     }
  1, 0,                                      //  3102:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3104:      check predicate 35
  OPC_Decode, 241, 22, 239, 1,               //  3106:      decode to VMAXsv4i32 using decoder 239
                                             //  3106:     }
                                             //  3106:     } // switch Inst[6]
                                             //  3106:    }
  229, 3, 21,                                //  3111:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  3114:     switch Inst[6] {
  0, 7,                                      //  3117:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3119:      check predicate 35
  OPC_Decode, 197, 30, 244, 1,               //  3121:      decode to VSUBHNv2i32 using decoder 244
                                             //  3121:     }
  1, 0,                                      //  3126:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3128:      check predicate 35
  OPC_Decode, 171, 23, 128, 2,               //  3130:      decode to VMLSLslsv2i32 using decoder 256
                                             //  3130:     }
                                             //  3130:     } // switch Inst[6]
                                             //  3130:    }
  230, 3, 21,                                //  3135:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  3138:     switch Inst[6] {
  0, 7,                                      //  3141:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3143:      check predicate 35
  OPC_Decode, 245, 22, 238, 1,               //  3145:      decode to VMAXuv2i32 using decoder 238
                                             //  3145:     }
  1, 0,                                      //  3150:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3152:      check predicate 35
  OPC_Decode, 247, 22, 239, 1,               //  3154:      decode to VMAXuv4i32 using decoder 239
                                             //  3154:     }
                                             //  3154:     } // switch Inst[6]
                                             //  3154:    }
  231, 3, 0,                                 //  3159:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  3162:     switch Inst[6] {
  0, 7,                                      //  3165:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3167:      check predicate 35
  OPC_Decode, 172, 27, 244, 1,               //  3169:      decode to VRSUBHNv2i32 using decoder 244
                                             //  3169:     }
  1, 0,                                      //  3174:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3176:      check predicate 35
  OPC_Decode, 173, 23, 128, 2,               //  3178:      decode to VMLSLsluv2i32 using decoder 256
                                             //  3178:     }
                                             //  3178:     } // switch Inst[6]
                                             //  3178:    }
                                             //  3178:    } // switch Inst[31:23]
                                             //  3178:   }
  7, 89,                                     //  3183:   case 0x7: {
  OPC_SwitchField, 23, 9,                    //  3185:    switch Inst[31:23] {
  228, 3, 21,                                //  3188:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  3191:     switch Inst[6] {
  0, 7,                                      //  3194:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3196:      check predicate 35
  OPC_Decode, 209, 16, 238, 1,               //  3198:      decode to VABDsv2i32 using decoder 238
                                             //  3198:     }
  1, 0,                                      //  3203:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3205:      check predicate 35
  OPC_Decode, 211, 16, 239, 1,               //  3207:      decode to VABDsv4i32 using decoder 239
                                             //  3207:     }
                                             //  3207:     } // switch Inst[6]
                                             //  3207:    }
  229, 3, 21,                                //  3212:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  3215:     switch Inst[6] {
  0, 7,                                      //  3218:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3220:      check predicate 35
  OPC_Decode, 198, 16, 240, 1,               //  3222:      decode to VABDLsv2i64 using decoder 240
                                             //  3222:     }
  1, 0,                                      //  3227:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3229:      check predicate 35
  OPC_Decode, 140, 25, 128, 2,               //  3231:      decode to VQDMLSLslv2i32 using decoder 256
                                             //  3231:     }
                                             //  3231:     } // switch Inst[6]
                                             //  3231:    }
  230, 3, 21,                                //  3236:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  3239:     switch Inst[6] {
  0, 7,                                      //  3242:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3244:      check predicate 35
  OPC_Decode, 215, 16, 238, 1,               //  3246:      decode to VABDuv2i32 using decoder 238
                                             //  3246:     }
  1, 0,                                      //  3251:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3253:      check predicate 35
  OPC_Decode, 217, 16, 239, 1,               //  3255:      decode to VABDuv4i32 using decoder 239
                                             //  3255:     }
                                             //  3255:     } // switch Inst[6]
                                             //  3255:    }
  231, 3, 0,                                 //  3260:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //  3263:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //  3265:     check Inst[6] == 0x0
  OPC_Decode, 201, 16, 240, 1,               //  3269:     decode to VABDLuv2i64 using decoder 240
                                             //  3269:    }
                                             //  3269:    } // switch Inst[31:23]
                                             //  3269:   }
  8, 99,                                     //  3274:   case 0x8: {
  OPC_SwitchField, 23, 9,                    //  3276:    switch Inst[31:23] {
  228, 3, 21,                                //  3279:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  3282:     switch Inst[6] {
  0, 7,                                      //  3285:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3287:      check predicate 35
  OPC_Decode, 137, 17, 238, 1,               //  3289:      decode to VADDv2i32 using decoder 238
                                             //  3289:     }
  1, 0,                                      //  3294:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3296:      check predicate 35
  OPC_Decode, 140, 17, 239, 1,               //  3298:      decode to VADDv4i32 using decoder 239
                                             //  3298:     }
                                             //  3298:     } // switch Inst[6]
                                             //  3298:    }
  229, 3, 21,                                //  3303:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  3306:     switch Inst[6] {
  0, 7,                                      //  3309:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3311:      check predicate 35
  OPC_Decode, 144, 23, 245, 1,               //  3313:      decode to VMLALsv2i64 using decoder 245
                                             //  3313:     }
  1, 0,                                      //  3318:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3320:      check predicate 35
  OPC_Decode, 151, 24, 129, 2,               //  3322:      decode to VMULslv2i32 using decoder 257
                                             //  3322:     }
                                             //  3322:     } // switch Inst[6]
                                             //  3322:    }
  230, 3, 21,                                //  3327:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  3330:     switch Inst[6] {
  0, 7,                                      //  3333:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3335:      check predicate 35
  OPC_Decode, 219, 30, 238, 1,               //  3337:      decode to VSUBv2i32 using decoder 238
                                             //  3337:     }
  1, 0,                                      //  3342:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3344:      check predicate 35
  OPC_Decode, 222, 30, 239, 1,               //  3346:      decode to VSUBv4i32 using decoder 239
                                             //  3346:     }
                                             //  3346:     } // switch Inst[6]
                                             //  3346:    }
  231, 3, 0,                                 //  3351:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  3354:     switch Inst[6] {
  0, 7,                                      //  3357:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3359:      check predicate 35
  OPC_Decode, 147, 23, 245, 1,               //  3361:      decode to VMLALuv2i64 using decoder 245
                                             //  3361:     }
  1, 0,                                      //  3366:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3368:      check predicate 35
  OPC_Decode, 153, 24, 130, 2,               //  3370:      decode to VMULslv4i32 using decoder 258
                                             //  3370:     }
                                             //  3370:     } // switch Inst[6]
                                             //  3370:    }
                                             //  3370:    } // switch Inst[31:23]
                                             //  3370:   }
  9, 89,                                     //  3375:   case 0x9: {
  OPC_SwitchField, 23, 9,                    //  3377:    switch Inst[31:23] {
  228, 3, 21,                                //  3380:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  3383:     switch Inst[6] {
  0, 7,                                      //  3386:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3388:      check predicate 35
  OPC_Decode, 164, 23, 246, 1,               //  3390:      decode to VMLAv2i32 using decoder 246
                                             //  3390:     }
  1, 0,                                      //  3395:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3397:      check predicate 35
  OPC_Decode, 166, 23, 247, 1,               //  3399:      decode to VMLAv4i32 using decoder 247
                                             //  3399:     }
                                             //  3399:     } // switch Inst[6]
                                             //  3399:    }
  229, 3, 21,                                //  3404:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  3407:     switch Inst[6] {
  0, 7,                                      //  3410:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3412:      check predicate 35
  OPC_Decode, 138, 25, 245, 1,               //  3414:      decode to VQDMLALv2i64 using decoder 245
                                             //  3414:     }
  1, 0,                                      //  3419:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3421:      check predicate 35
  OPC_Decode, 147, 24, 129, 2,               //  3423:      decode to VMULslfd using decoder 257
                                             //  3423:     }
                                             //  3423:     } // switch Inst[6]
                                             //  3423:    }
  230, 3, 21,                                //  3428:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  3431:     switch Inst[6] {
  0, 7,                                      //  3434:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3436:      check predicate 35
  OPC_Decode, 195, 23, 246, 1,               //  3438:      decode to VMLSv2i32 using decoder 246
                                             //  3438:     }
  1, 0,                                      //  3443:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3445:      check predicate 35
  OPC_Decode, 197, 23, 247, 1,               //  3447:      decode to VMLSv4i32 using decoder 247
                                             //  3447:     }
                                             //  3447:     } // switch Inst[6]
                                             //  3447:    }
  231, 3, 0,                                 //  3452:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //  3455:     check predicate 35
  OPC_CheckField, 6, 1, 1,                   //  3457:     check Inst[6] == 0x1
  OPC_Decode, 148, 24, 130, 2,               //  3461:     decode to VMULslfq using decoder 258
                                             //  3461:    }
                                             //  3461:    } // switch Inst[31:23]
                                             //  3461:   }
  10, 79,                                    //  3466:   case 0xa: {
  OPC_SwitchField, 23, 9,                    //  3468:    switch Inst[31:23] {
  228, 3, 11,                                //  3471:    case 0x1e4: {
  OPC_CheckPredicate, 35,                    //  3474:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //  3476:     check Inst[6] == 0x0
  OPC_Decode, 229, 24, 238, 1,               //  3480:     decode to VPMAXs32 using decoder 238
                                             //  3480:    }
  229, 3, 21,                                //  3485:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  3488:     switch Inst[6] {
  0, 7,                                      //  3491:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3493:      check predicate 35
  OPC_Decode, 175, 23, 245, 1,               //  3495:      decode to VMLSLsv2i64 using decoder 245
                                             //  3495:     }
  1, 0,                                      //  3500:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3502:      check predicate 35
  OPC_Decode, 130, 24, 131, 2,               //  3504:      decode to VMULLslsv2i32 using decoder 259
                                             //  3504:     }
                                             //  3504:     } // switch Inst[6]
                                             //  3504:    }
  230, 3, 11,                                //  3509:    case 0x1e6: {
  OPC_CheckPredicate, 35,                    //  3512:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //  3514:     check Inst[6] == 0x0
  OPC_Decode, 232, 24, 238, 1,               //  3518:     decode to VPMAXu32 using decoder 238
                                             //  3518:    }
  231, 3, 0,                                 //  3523:    case 0x1e7: {
  OPC_SwitchField, 6, 1,                     //  3526:     switch Inst[6] {
  0, 7,                                      //  3529:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3531:      check predicate 35
  OPC_Decode, 178, 23, 245, 1,               //  3533:      decode to VMLSLuv2i64 using decoder 245
                                             //  3533:     }
  1, 0,                                      //  3538:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3540:      check predicate 35
  OPC_Decode, 132, 24, 131, 2,               //  3542:      decode to VMULLsluv2i32 using decoder 259
                                             //  3542:     }
                                             //  3542:     } // switch Inst[6]
                                             //  3542:    }
                                             //  3542:    } // switch Inst[31:23]
                                             //  3542:   }
  11, 75,                                    //  3547:   case 0xb: {
  OPC_SwitchField, 23, 9,                    //  3549:    switch Inst[31:23] {
  228, 3, 21,                                //  3552:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  3555:     switch Inst[6] {
  0, 7,                                      //  3558:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3560:      check predicate 35
  OPC_Decode, 148, 25, 238, 1,               //  3562:      decode to VQDMULHv2i32 using decoder 238
                                             //  3562:     }
  1, 0,                                      //  3567:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3569:      check predicate 35
  OPC_Decode, 150, 25, 239, 1,               //  3571:      decode to VQDMULHv4i32 using decoder 239
                                             //  3571:     }
                                             //  3571:     } // switch Inst[6]
                                             //  3571:    }
  229, 3, 21,                                //  3576:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  3579:     switch Inst[6] {
  0, 7,                                      //  3582:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3584:      check predicate 35
  OPC_Decode, 142, 25, 245, 1,               //  3586:      decode to VQDMLSLv2i64 using decoder 245
                                             //  3586:     }
  1, 0,                                      //  3591:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3593:      check predicate 35
  OPC_Decode, 152, 25, 131, 2,               //  3595:      decode to VQDMULLslv2i32 using decoder 259
                                             //  3595:     }
                                             //  3595:     } // switch Inst[6]
                                             //  3595:    }
  230, 3, 0,                                 //  3600:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  3603:     switch Inst[6] {
  0, 7,                                      //  3606:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3608:      check predicate 35
  OPC_Decode, 191, 25, 238, 1,               //  3610:      decode to VQRDMULHv2i32 using decoder 238
                                             //  3610:     }
  1, 0,                                      //  3615:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3617:      check predicate 35
  OPC_Decode, 193, 25, 239, 1,               //  3619:      decode to VQRDMULHv4i32 using decoder 239
                                             //  3619:     }
                                             //  3619:     } // switch Inst[6]
                                             //  3619:    }
                                             //  3619:    } // switch Inst[31:23]
                                             //  3619:   }
  12, 53,                                    //  3624:   case 0xc: {
  OPC_SwitchField, 6, 1,                     //  3626:    switch Inst[6] {
  0, 23,                                     //  3629:    case 0x0: {
  OPC_SwitchField, 23, 9,                    //  3631:     switch Inst[31:23] {
  229, 3, 7,                                 //  3634:     case 0x1e5: {
  OPC_CheckPredicate, 35,                    //  3637:      check predicate 35
  OPC_Decode, 134, 24, 240, 1,               //  3639:      decode to VMULLsv2i64 using decoder 240
                                             //  3639:     }
  231, 3, 0,                                 //  3644:     case 0x1e7: {
  OPC_CheckPredicate, 35,                    //  3647:      check predicate 35
  OPC_Decode, 137, 24, 240, 1,               //  3649:      decode to VMULLuv2i64 using decoder 240
                                             //  3649:     }
                                             //  3649:     } // switch Inst[31:23]
                                             //  3649:    }
  1, 0,                                      //  3654:    case 0x1: {
  OPC_SwitchField, 23, 9,                    //  3656:     switch Inst[31:23] {
  229, 3, 7,                                 //  3659:     case 0x1e5: {
  OPC_CheckPredicate, 35,                    //  3662:      check predicate 35
  OPC_Decode, 144, 25, 129, 2,               //  3664:      decode to VQDMULHslv2i32 using decoder 257
                                             //  3664:     }
  231, 3, 0,                                 //  3669:     case 0x1e7: {
  OPC_CheckPredicate, 35,                    //  3672:      check predicate 35
  OPC_Decode, 146, 25, 130, 2,               //  3674:      decode to VQDMULHslv4i32 using decoder 258
                                             //  3674:     }
                                             //  3674:     } // switch Inst[31:23]
                                             //  3674:    }
                                             //  3674:    } // switch Inst[6]
                                             //  3674:   }
  13, 89,                                    //  3679:   case 0xd: {
  OPC_SwitchField, 23, 9,                    //  3681:    switch Inst[31:23] {
  228, 3, 21,                                //  3684:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  3687:     switch Inst[6] {
  0, 7,                                      //  3690:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3692:      check predicate 35
  OPC_Decode, 213, 30, 238, 1,               //  3694:      decode to VSUBfd using decoder 238
                                             //  3694:     }
  1, 0,                                      //  3699:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3701:      check predicate 35
  OPC_Decode, 214, 30, 239, 1,               //  3703:      decode to VSUBfq using decoder 239
                                             //  3703:     }
                                             //  3703:     } // switch Inst[6]
                                             //  3703:    }
  229, 3, 21,                                //  3708:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  3711:     switch Inst[6] {
  0, 7,                                      //  3714:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3716:      check predicate 35
  OPC_Decode, 154, 25, 240, 1,               //  3718:      decode to VQDMULLv2i64 using decoder 240
                                             //  3718:     }
  1, 0,                                      //  3723:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3725:      check predicate 35
  OPC_Decode, 187, 25, 129, 2,               //  3727:      decode to VQRDMULHslv2i32 using decoder 257
                                             //  3727:     }
                                             //  3727:     } // switch Inst[6]
                                             //  3727:    }
  230, 3, 21,                                //  3732:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  3735:     switch Inst[6] {
  0, 7,                                      //  3738:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3740:      check predicate 35
  OPC_Decode, 204, 16, 238, 1,               //  3742:      decode to VABDfd using decoder 238
                                             //  3742:     }
  1, 0,                                      //  3747:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3749:      check predicate 35
  OPC_Decode, 205, 16, 239, 1,               //  3751:      decode to VABDfq using decoder 239
                                             //  3751:     }
                                             //  3751:     } // switch Inst[6]
                                             //  3751:    }
  231, 3, 0,                                 //  3756:    case 0x1e7: {
  OPC_CheckPredicate, 35,                    //  3759:     check predicate 35
  OPC_CheckField, 6, 1, 1,                   //  3761:     check Inst[6] == 0x1
  OPC_Decode, 189, 25, 130, 2,               //  3765:     decode to VQRDMULHslv4i32 using decoder 258
                                             //  3765:    }
                                             //  3765:    } // switch Inst[31:23]
                                             //  3765:   }
  14, 65,                                    //  3770:   case 0xe: {
  OPC_SwitchField, 23, 9,                    //  3772:    switch Inst[31:23] {
  229, 3, 21,                                //  3775:    case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  3778:     switch Inst[6] {
  0, 7,                                      //  3781:     case 0x0: {
  OPC_CheckPredicate, 38,                    //  3783:      check predicate 38
  OPC_Decode, 128, 24, 132, 2,               //  3785:      decode to VMULLp64 using decoder 260
                                             //  3785:     }
  1, 0,                                      //  3790:     case 0x1: {
  OPC_CheckPredicate, 37,                    //  3792:      check predicate 37
  OPC_Decode, 171, 25, 254, 1,               //  3794:      decode to VQRDMLAHslv2i32 using decoder 254
                                             //  3794:     }
                                             //  3794:     } // switch Inst[6]
                                             //  3794:    }
  230, 3, 21,                                //  3799:    case 0x1e6: {
  OPC_SwitchField, 6, 1,                     //  3802:     switch Inst[6] {
  0, 7,                                      //  3805:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3807:      check predicate 35
  OPC_Decode, 213, 17, 238, 1,               //  3809:      decode to VCGTfd using decoder 238
                                             //  3809:     }
  1, 0,                                      //  3814:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3816:      check predicate 35
  OPC_Decode, 214, 17, 239, 1,               //  3818:      decode to VCGTfq using decoder 239
                                             //  3818:     }
                                             //  3818:     } // switch Inst[6]
                                             //  3818:    }
  231, 3, 0,                                 //  3823:    case 0x1e7: {
  OPC_CheckPredicate, 37,                    //  3826:     check predicate 37
  OPC_CheckField, 6, 1, 1,                   //  3828:     check Inst[6] == 0x1
  OPC_Decode, 173, 25, 255, 1,               //  3832:     decode to VQRDMLAHslv4i32 using decoder 255
                                             //  3832:    }
                                             //  3832:    } // switch Inst[31:23]
                                             //  3832:   }
  15, 0,                                     //  3837:   case 0xf: {
  OPC_SwitchField, 23, 9,                    //  3839:    switch Inst[31:23] {
  228, 3, 21,                                //  3842:    case 0x1e4: {
  OPC_SwitchField, 6, 1,                     //  3845:     switch Inst[6] {
  0, 7,                                      //  3848:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3850:      check predicate 35
  OPC_Decode, 250, 22, 238, 1,               //  3852:      decode to VMINfd using decoder 238
                                             //  3852:     }
  1, 0,                                      //  3857:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3859:      check predicate 35
  OPC_Decode, 251, 22, 239, 1,               //  3861:      decode to VMINfq using decoder 239
                                             //  3861:     }
                                             //  3861:     } // switch Inst[6]
                                             //  3861:    }
  229, 3, 11,                                //  3866:    case 0x1e5: {
  OPC_CheckPredicate, 37,                    //  3869:     check predicate 37
  OPC_CheckField, 6, 1, 1,                   //  3871:     check Inst[6] == 0x1
  OPC_Decode, 179, 25, 254, 1,               //  3875:     decode to VQRDMLSHslv2i32 using decoder 254
                                             //  3875:    }
  230, 3, 11,                                //  3880:    case 0x1e6: {
  OPC_CheckPredicate, 35,                    //  3883:     check predicate 35
  OPC_CheckField, 6, 1, 0,                   //  3885:     check Inst[6] == 0x0
  OPC_Decode, 234, 24, 238, 1,               //  3889:     decode to VPMINf using decoder 238
                                             //  3889:    }
  231, 3, 0,                                 //  3894:    case 0x1e7: {
  OPC_CheckPredicate, 37,                    //  3897:     check predicate 37
  OPC_CheckField, 6, 1, 1,                   //  3899:     check Inst[6] == 0x1
  OPC_Decode, 181, 25, 255, 1,               //  3903:     decode to VQRDMLSHslv4i32 using decoder 255
                                             //  3903:    }
                                             //  3903:    } // switch Inst[31:23]
                                             //  3903:   }
                                             //  3903:   } // switch Inst[11:8]
                                             //  3903:  }
  3, 0,                                      //  3908:  case 0x3: {
  OPC_SwitchField, 23, 9,                    //  3910:   switch Inst[31:23] {
  228, 3, 118,                               //  3913:   case 0x1e4: {
  OPC_SwitchField, 8, 4,                     //  3916:    switch Inst[11:8] {
  4, 21,                                     //  3919:    case 0x4: {
  OPC_SwitchField, 6, 1,                     //  3921:     switch Inst[6] {
  0, 7,                                      //  3924:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3926:      check predicate 35
  OPC_Decode, 214, 27, 242, 1,               //  3928:      decode to VSHLsv1i64 using decoder 242
                                             //  3928:     }
  1, 0,                                      //  3933:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3935:      check predicate 35
  OPC_Decode, 216, 27, 243, 1,               //  3937:      decode to VSHLsv2i64 using decoder 243
                                             //  3937:     }
                                             //  3937:     } // switch Inst[6]
                                             //  3937:    }
  5, 21,                                     //  3942:    case 0x5: {
  OPC_SwitchField, 6, 1,                     //  3944:     switch Inst[6] {
  0, 7,                                      //  3947:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3949:      check predicate 35
  OPC_Decode, 240, 26, 242, 1,               //  3951:      decode to VRSHLsv1i64 using decoder 242
                                             //  3951:     }
  1, 0,                                      //  3956:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3958:      check predicate 35
  OPC_Decode, 242, 26, 243, 1,               //  3960:      decode to VRSHLsv2i64 using decoder 243
                                             //  3960:     }
                                             //  3960:     } // switch Inst[6]
                                             //  3960:    }
  8, 21,                                     //  3965:    case 0x8: {
  OPC_SwitchField, 6, 1,                     //  3967:     switch Inst[6] {
  0, 7,                                      //  3970:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  3972:      check predicate 35
  OPC_Decode, 136, 17, 238, 1,               //  3974:      decode to VADDv1i64 using decoder 238
                                             //  3974:     }
  1, 0,                                      //  3979:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  3981:      check predicate 35
  OPC_Decode, 138, 17, 239, 1,               //  3983:      decode to VADDv2i64 using decoder 239
                                             //  3983:     }
                                             //  3983:     } // switch Inst[6]
                                             //  3983:    }
  13, 21,                                    //  3988:    case 0xd: {
  OPC_SwitchField, 6, 1,                     //  3990:     switch Inst[6] {
  0, 7,                                      //  3993:     case 0x0: {
  OPC_CheckPredicate, 36,                    //  3995:      check predicate 36
  OPC_Decode, 215, 30, 238, 1,               //  3997:      decode to VSUBhd using decoder 238
                                             //  3997:     }
  1, 0,                                      //  4002:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  4004:      check predicate 36
  OPC_Decode, 216, 30, 239, 1,               //  4006:      decode to VSUBhq using decoder 239
                                             //  4006:     }
                                             //  4006:     } // switch Inst[6]
                                             //  4006:    }
  15, 0,                                     //  4011:    case 0xf: {
  OPC_SwitchField, 6, 1,                     //  4013:     switch Inst[6] {
  0, 7,                                      //  4016:     case 0x0: {
  OPC_CheckPredicate, 36,                    //  4018:      check predicate 36
  OPC_Decode, 252, 22, 238, 1,               //  4020:      decode to VMINhd using decoder 238
                                             //  4020:     }
  1, 0,                                      //  4025:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  4027:      check predicate 36
  OPC_Decode, 253, 22, 239, 1,               //  4029:      decode to VMINhq using decoder 239
                                             //  4029:     }
                                             //  4029:     } // switch Inst[6]
                                             //  4029:    }
                                             //  4029:    } // switch Inst[11:8]
                                             //  4029:   }
  229, 3, 90,                                //  4034:   case 0x1e5: {
  OPC_SwitchField, 6, 1,                     //  4037:    switch Inst[6] {
  0, 37,                                     //  4040:    case 0x0: {
  OPC_CheckField, 11, 1, 0,                  //  4042:     check Inst[11] == 0x0
  OPC_Scope, 11,                             //  4046:     try {
  OPC_CheckField, 8, 2, 0,                   //  4048:      check Inst[9:8] == 0x0
  OPC_CheckPredicate, 35,                    //  4052:      check predicate 35
  OPC_Decode, 155, 19, 133, 2,               //  4054:      decode to VEXTd32 using decoder 261
  OPC_Scope, 11,                             //  4059:     } else try {
  OPC_CheckField, 8, 1, 0,                   //  4061:      check Inst[8] == 0x0
  OPC_CheckPredicate, 35,                    //  4065:      check predicate 35
  OPC_Decode, 154, 19, 134, 2,               //  4067:      decode to VEXTd16 using decoder 262
                                             //  4067:     } else try {
  OPC_CheckPredicate, 35,                    //  4072:      check predicate 35
  OPC_Decode, 156, 19, 135, 2,               //  4074:      decode to VEXTd8 using decoder 263
                                             //  4074:     }
                                             //  4074:    }
  1, 0,                                      //  4079:    case 0x1: {
  OPC_Scope, 11,                             //  4081:     try {
  OPC_CheckField, 8, 3, 0,                   //  4083:      check Inst[10:8] == 0x0
  OPC_CheckPredicate, 35,                    //  4087:      check predicate 35
  OPC_Decode, 159, 19, 136, 2,               //  4089:      decode to VEXTq64 using decoder 264
  OPC_Scope, 11,                             //  4094:     } else try {
  OPC_CheckField, 8, 2, 0,                   //  4096:      check Inst[9:8] == 0x0
  OPC_CheckPredicate, 35,                    //  4100:      check predicate 35
  OPC_Decode, 158, 19, 137, 2,               //  4102:      decode to VEXTq32 using decoder 265
  OPC_Scope, 11,                             //  4107:     } else try {
  OPC_CheckField, 8, 1, 0,                   //  4109:      check Inst[8] == 0x0
  OPC_CheckPredicate, 35,                    //  4113:      check predicate 35
  OPC_Decode, 157, 19, 138, 2,               //  4115:      decode to VEXTq16 using decoder 266
                                             //  4115:     } else try {
  OPC_CheckPredicate, 35,                    //  4120:      check predicate 35
  OPC_Decode, 160, 19, 139, 2,               //  4122:      decode to VEXTq8 using decoder 267
                                             //  4122:     }
                                             //  4122:    }
                                             //  4122:    } // switch Inst[6]
                                             //  4122:   }
  230, 3, 131, 1,                            //  4127:   case 0x1e6: {
  OPC_SwitchField, 8, 4,                     //  4131:    switch Inst[11:8] {
  4, 21,                                     //  4134:    case 0x4: {
  OPC_SwitchField, 6, 1,                     //  4136:     switch Inst[6] {
  0, 7,                                      //  4139:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  4141:      check predicate 35
  OPC_Decode, 222, 27, 242, 1,               //  4143:      decode to VSHLuv1i64 using decoder 242
                                             //  4143:     }
  1, 0,                                      //  4148:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  4150:      check predicate 35
  OPC_Decode, 224, 27, 243, 1,               //  4152:      decode to VSHLuv2i64 using decoder 243
                                             //  4152:     }
                                             //  4152:     } // switch Inst[6]
                                             //  4152:    }
  5, 21,                                     //  4157:    case 0x5: {
  OPC_SwitchField, 6, 1,                     //  4159:     switch Inst[6] {
  0, 7,                                      //  4162:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  4164:      check predicate 35
  OPC_Decode, 248, 26, 242, 1,               //  4166:      decode to VRSHLuv1i64 using decoder 242
                                             //  4166:     }
  1, 0,                                      //  4171:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  4173:      check predicate 35
  OPC_Decode, 250, 26, 243, 1,               //  4175:      decode to VRSHLuv2i64 using decoder 243
                                             //  4175:     }
                                             //  4175:     } // switch Inst[6]
                                             //  4175:    }
  8, 21,                                     //  4180:    case 0x8: {
  OPC_SwitchField, 6, 1,                     //  4182:     switch Inst[6] {
  0, 7,                                      //  4185:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  4187:      check predicate 35
  OPC_Decode, 218, 30, 238, 1,               //  4189:      decode to VSUBv1i64 using decoder 238
                                             //  4189:     }
  1, 0,                                      //  4194:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  4196:      check predicate 35
  OPC_Decode, 220, 30, 239, 1,               //  4198:      decode to VSUBv2i64 using decoder 239
                                             //  4198:     }
                                             //  4198:     } // switch Inst[6]
                                             //  4198:    }
  13, 21,                                    //  4203:    case 0xd: {
  OPC_SwitchField, 6, 1,                     //  4205:     switch Inst[6] {
  0, 7,                                      //  4208:     case 0x0: {
  OPC_CheckPredicate, 36,                    //  4210:      check predicate 36
  OPC_Decode, 206, 16, 238, 1,               //  4212:      decode to VABDhd using decoder 238
                                             //  4212:     }
  1, 0,                                      //  4217:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  4219:      check predicate 36
  OPC_Decode, 207, 16, 239, 1,               //  4221:      decode to VABDhq using decoder 239
                                             //  4221:     }
                                             //  4221:     } // switch Inst[6]
                                             //  4221:    }
  14, 21,                                    //  4226:    case 0xe: {
  OPC_SwitchField, 6, 1,                     //  4228:     switch Inst[6] {
  0, 7,                                      //  4231:     case 0x0: {
  OPC_CheckPredicate, 36,                    //  4233:      check predicate 36
  OPC_Decode, 215, 17, 238, 1,               //  4235:      decode to VCGThd using decoder 238
                                             //  4235:     }
  1, 0,                                      //  4240:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  4242:      check predicate 36
  OPC_Decode, 216, 17, 239, 1,               //  4244:      decode to VCGThq using decoder 239
                                             //  4244:     }
                                             //  4244:     } // switch Inst[6]
                                             //  4244:    }
  15, 0,                                     //  4249:    case 0xf: {
  OPC_CheckPredicate, 36,                    //  4251:     check predicate 36
  OPC_CheckField, 6, 1, 0,                   //  4253:     check Inst[6] == 0x0
  OPC_Decode, 235, 24, 238, 1,               //  4257:     decode to VPMINh using decoder 238
                                             //  4257:    }
                                             //  4257:    } // switch Inst[11:8]
                                             //  4257:   }
  231, 3, 0,                                 //  4262:   case 0x1e7: {
  OPC_SwitchField, 8, 4,                     //  4265:    switch Inst[11:8] {
  0, 190, 2,                                 //  4268:    case 0x0: {
  OPC_SwitchField, 16, 4,                    //  4271:     switch Inst[19:16] {
  0, 39,                                     //  4274:     case 0x0: {
  OPC_SwitchField, 6, 2,                     //  4276:      switch Inst[7:6] {
  0, 7,                                      //  4279:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4281:       check predicate 35
  OPC_Decode, 178, 26, 140, 2,               //  4283:       decode to VREV64d8 using decoder 268
                                             //  4283:      }
  1, 7,                                      //  4288:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4290:       check predicate 35
  OPC_Decode, 181, 26, 141, 2,               //  4292:       decode to VREV64q8 using decoder 269
                                             //  4292:      }
  2, 7,                                      //  4297:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4299:       check predicate 35
  OPC_Decode, 173, 26, 140, 2,               //  4301:       decode to VREV32d8 using decoder 268
                                             //  4301:      }
  3, 0,                                      //  4306:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4308:       check predicate 35
  OPC_Decode, 175, 26, 141, 2,               //  4310:       decode to VREV32q8 using decoder 269
                                             //  4310:      }
                                             //  4310:      } // switch Inst[7:6]
                                             //  4310:     }
  1, 39,                                     //  4315:     case 0x1: {
  OPC_SwitchField, 6, 2,                     //  4317:      switch Inst[7:6] {
  0, 7,                                      //  4320:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4322:       check predicate 35
  OPC_Decode, 238, 17, 140, 2,               //  4324:       decode to VCGTzv8i8 using decoder 268
                                             //  4324:      }
  1, 7,                                      //  4329:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4331:       check predicate 35
  OPC_Decode, 229, 17, 141, 2,               //  4333:       decode to VCGTzv16i8 using decoder 269
                                             //  4333:      }
  2, 7,                                      //  4338:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4340:       check predicate 35
  OPC_Decode, 212, 17, 140, 2,               //  4342:       decode to VCGEzv8i8 using decoder 268
                                             //  4342:      }
  3, 0,                                      //  4347:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4349:       check predicate 35
  OPC_Decode, 203, 17, 141, 2,               //  4351:       decode to VCGEzv16i8 using decoder 269
                                             //  4351:      }
                                             //  4351:      } // switch Inst[7:6]
                                             //  4351:     }
  2, 39,                                     //  4356:     case 0x2: {
  OPC_SwitchField, 6, 2,                     //  4358:      switch Inst[7:6] {
  0, 7,                                      //  4361:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4363:       check predicate 35
  OPC_Decode, 227, 30, 142, 2,               //  4365:       decode to VSWPd using decoder 270
                                             //  4365:      }
  1, 7,                                      //  4370:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4372:       check predicate 35
  OPC_Decode, 228, 30, 143, 2,               //  4374:       decode to VSWPq using decoder 271
                                             //  4374:      }
  2, 7,                                      //  4379:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4381:       check predicate 35
  OPC_Decode, 139, 31, 142, 2,               //  4383:       decode to VTRNd8 using decoder 270
                                             //  4383:      }
  3, 0,                                      //  4388:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4390:       check predicate 35
  OPC_Decode, 142, 31, 143, 2,               //  4392:       decode to VTRNq8 using decoder 271
                                             //  4392:      }
                                             //  4392:      } // switch Inst[7:6]
                                             //  4392:     }
  4, 39,                                     //  4397:     case 0x4: {
  OPC_SwitchField, 6, 2,                     //  4399:      switch Inst[7:6] {
  0, 7,                                      //  4402:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4404:       check predicate 35
  OPC_Decode, 176, 26, 140, 2,               //  4406:       decode to VREV64d16 using decoder 268
                                             //  4406:      }
  1, 7,                                      //  4411:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4413:       check predicate 35
  OPC_Decode, 179, 26, 141, 2,               //  4415:       decode to VREV64q16 using decoder 269
                                             //  4415:      }
  2, 7,                                      //  4420:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4422:       check predicate 35
  OPC_Decode, 172, 26, 140, 2,               //  4424:       decode to VREV32d16 using decoder 268
                                             //  4424:      }
  3, 0,                                      //  4429:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4431:       check predicate 35
  OPC_Decode, 174, 26, 141, 2,               //  4433:       decode to VREV32q16 using decoder 269
                                             //  4433:      }
                                             //  4433:      } // switch Inst[7:6]
                                             //  4433:     }
  5, 39,                                     //  4438:     case 0x5: {
  OPC_SwitchField, 6, 2,                     //  4440:      switch Inst[7:6] {
  0, 7,                                      //  4443:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4445:       check predicate 35
  OPC_Decode, 234, 17, 140, 2,               //  4447:       decode to VCGTzv4i16 using decoder 268
                                             //  4447:      }
  1, 7,                                      //  4452:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4454:       check predicate 35
  OPC_Decode, 237, 17, 141, 2,               //  4456:       decode to VCGTzv8i16 using decoder 269
                                             //  4456:      }
  2, 7,                                      //  4461:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4463:       check predicate 35
  OPC_Decode, 208, 17, 140, 2,               //  4465:       decode to VCGEzv4i16 using decoder 268
                                             //  4465:      }
  3, 0,                                      //  4470:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4472:       check predicate 35
  OPC_Decode, 211, 17, 141, 2,               //  4474:       decode to VCGEzv8i16 using decoder 269
                                             //  4474:      }
                                             //  4474:      } // switch Inst[7:6]
                                             //  4474:     }
  6, 21,                                     //  4479:     case 0x6: {
  OPC_SwitchField, 6, 2,                     //  4481:      switch Inst[7:6] {
  2, 7,                                      //  4484:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4486:       check predicate 35
  OPC_Decode, 137, 31, 142, 2,               //  4488:       decode to VTRNd16 using decoder 270
                                             //  4488:      }
  3, 0,                                      //  4493:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4495:       check predicate 35
  OPC_Decode, 140, 31, 143, 2,               //  4497:       decode to VTRNq16 using decoder 271
                                             //  4497:      }
                                             //  4497:      } // switch Inst[7:6]
                                             //  4497:     }
  8, 21,                                     //  4502:     case 0x8: {
  OPC_SwitchField, 6, 2,                     //  4504:      switch Inst[7:6] {
  0, 7,                                      //  4507:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4509:       check predicate 35
  OPC_Decode, 177, 26, 140, 2,               //  4511:       decode to VREV64d32 using decoder 268
                                             //  4511:      }
  1, 0,                                      //  4516:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4518:       check predicate 35
  OPC_Decode, 180, 26, 141, 2,               //  4520:       decode to VREV64q32 using decoder 269
                                             //  4520:      }
                                             //  4520:      } // switch Inst[7:6]
                                             //  4520:     }
  9, 39,                                     //  4525:     case 0x9: {
  OPC_SwitchField, 6, 2,                     //  4527:      switch Inst[7:6] {
  0, 7,                                      //  4530:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4532:       check predicate 35
  OPC_Decode, 231, 17, 140, 2,               //  4534:       decode to VCGTzv2i32 using decoder 268
                                             //  4534:      }
  1, 7,                                      //  4539:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4541:       check predicate 35
  OPC_Decode, 235, 17, 141, 2,               //  4543:       decode to VCGTzv4i32 using decoder 269
                                             //  4543:      }
  2, 7,                                      //  4548:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4550:       check predicate 35
  OPC_Decode, 205, 17, 140, 2,               //  4552:       decode to VCGEzv2i32 using decoder 268
                                             //  4552:      }
  3, 0,                                      //  4557:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4559:       check predicate 35
  OPC_Decode, 209, 17, 141, 2,               //  4561:       decode to VCGEzv4i32 using decoder 269
                                             //  4561:      }
                                             //  4561:      } // switch Inst[7:6]
                                             //  4561:     }
  10, 0,                                     //  4566:     case 0xa: {
  OPC_SwitchField, 6, 2,                     //  4568:      switch Inst[7:6] {
  2, 7,                                      //  4571:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4573:       check predicate 35
  OPC_Decode, 138, 31, 142, 2,               //  4575:       decode to VTRNd32 using decoder 270
                                             //  4575:      }
  3, 0,                                      //  4580:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4582:       check predicate 35
  OPC_Decode, 141, 31, 143, 2,               //  4584:       decode to VTRNq32 using decoder 271
                                             //  4584:      }
                                             //  4584:      } // switch Inst[7:6]
                                             //  4584:     }
                                             //  4584:     } // switch Inst[19:16]
                                             //  4584:    }
  1, 254, 1,                                 //  4589:    case 0x1: {
  OPC_SwitchField, 16, 4,                    //  4592:     switch Inst[19:16] {
  0, 21,                                     //  4595:     case 0x0: {
  OPC_SwitchField, 6, 2,                     //  4597:      switch Inst[7:6] {
  0, 7,                                      //  4600:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4602:       check predicate 35
  OPC_Decode, 170, 26, 140, 2,               //  4604:       decode to VREV16d8 using decoder 268
                                             //  4604:      }
  1, 0,                                      //  4609:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4611:       check predicate 35
  OPC_Decode, 171, 26, 141, 2,               //  4613:       decode to VREV16q8 using decoder 269
                                             //  4613:      }
                                             //  4613:      } // switch Inst[7:6]
                                             //  4613:     }
  1, 39,                                     //  4618:     case 0x1: {
  OPC_SwitchField, 6, 2,                     //  4620:      switch Inst[7:6] {
  0, 7,                                      //  4623:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4625:       check predicate 35
  OPC_Decode, 186, 17, 140, 2,               //  4627:       decode to VCEQzv8i8 using decoder 268
                                             //  4627:      }
  1, 7,                                      //  4632:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4634:       check predicate 35
  OPC_Decode, 177, 17, 141, 2,               //  4636:       decode to VCEQzv16i8 using decoder 269
                                             //  4636:      }
  2, 7,                                      //  4641:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4643:       check predicate 35
  OPC_Decode, 248, 17, 140, 2,               //  4645:       decode to VCLEzv8i8 using decoder 268
                                             //  4645:      }
  3, 0,                                      //  4650:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4652:       check predicate 35
  OPC_Decode, 239, 17, 141, 2,               //  4654:       decode to VCLEzv16i8 using decoder 269
                                             //  4654:      }
                                             //  4654:      } // switch Inst[7:6]
                                             //  4654:     }
  2, 39,                                     //  4659:     case 0x2: {
  OPC_SwitchField, 6, 2,                     //  4661:      switch Inst[7:6] {
  0, 7,                                      //  4664:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4666:       check predicate 35
  OPC_Decode, 169, 31, 142, 2,               //  4668:       decode to VUZPd8 using decoder 270
                                             //  4668:      }
  1, 7,                                      //  4673:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4675:       check predicate 35
  OPC_Decode, 172, 31, 143, 2,               //  4677:       decode to VUZPq8 using decoder 271
                                             //  4677:      }
  2, 7,                                      //  4682:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4684:       check predicate 35
  OPC_Decode, 174, 31, 142, 2,               //  4686:       decode to VZIPd8 using decoder 270
                                             //  4686:      }
  3, 0,                                      //  4691:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4693:       check predicate 35
  OPC_Decode, 177, 31, 143, 2,               //  4695:       decode to VZIPq8 using decoder 271
                                             //  4695:      }
                                             //  4695:      } // switch Inst[7:6]
                                             //  4695:     }
  5, 39,                                     //  4700:     case 0x5: {
  OPC_SwitchField, 6, 2,                     //  4702:      switch Inst[7:6] {
  0, 7,                                      //  4705:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4707:       check predicate 35
  OPC_Decode, 182, 17, 140, 2,               //  4709:       decode to VCEQzv4i16 using decoder 268
                                             //  4709:      }
  1, 7,                                      //  4714:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4716:       check predicate 35
  OPC_Decode, 185, 17, 141, 2,               //  4718:       decode to VCEQzv8i16 using decoder 269
                                             //  4718:      }
  2, 7,                                      //  4723:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4725:       check predicate 35
  OPC_Decode, 244, 17, 140, 2,               //  4727:       decode to VCLEzv4i16 using decoder 268
                                             //  4727:      }
  3, 0,                                      //  4732:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4734:       check predicate 35
  OPC_Decode, 247, 17, 141, 2,               //  4736:       decode to VCLEzv8i16 using decoder 269
                                             //  4736:      }
                                             //  4736:      } // switch Inst[7:6]
                                             //  4736:     }
  6, 39,                                     //  4741:     case 0x6: {
  OPC_SwitchField, 6, 2,                     //  4743:      switch Inst[7:6] {
  0, 7,                                      //  4746:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4748:       check predicate 35
  OPC_Decode, 168, 31, 142, 2,               //  4750:       decode to VUZPd16 using decoder 270
                                             //  4750:      }
  1, 7,                                      //  4755:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4757:       check predicate 35
  OPC_Decode, 170, 31, 143, 2,               //  4759:       decode to VUZPq16 using decoder 271
                                             //  4759:      }
  2, 7,                                      //  4764:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4766:       check predicate 35
  OPC_Decode, 173, 31, 142, 2,               //  4768:       decode to VZIPd16 using decoder 270
                                             //  4768:      }
  3, 0,                                      //  4773:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4775:       check predicate 35
  OPC_Decode, 175, 31, 143, 2,               //  4777:       decode to VZIPq16 using decoder 271
                                             //  4777:      }
                                             //  4777:      } // switch Inst[7:6]
                                             //  4777:     }
  9, 39,                                     //  4782:     case 0x9: {
  OPC_SwitchField, 6, 2,                     //  4784:      switch Inst[7:6] {
  0, 7,                                      //  4787:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4789:       check predicate 35
  OPC_Decode, 179, 17, 140, 2,               //  4791:       decode to VCEQzv2i32 using decoder 268
                                             //  4791:      }
  1, 7,                                      //  4796:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4798:       check predicate 35
  OPC_Decode, 183, 17, 141, 2,               //  4800:       decode to VCEQzv4i32 using decoder 269
                                             //  4800:      }
  2, 7,                                      //  4805:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4807:       check predicate 35
  OPC_Decode, 241, 17, 140, 2,               //  4809:       decode to VCLEzv2i32 using decoder 268
                                             //  4809:      }
  3, 0,                                      //  4814:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4816:       check predicate 35
  OPC_Decode, 245, 17, 141, 2,               //  4818:       decode to VCLEzv4i32 using decoder 269
                                             //  4818:      }
                                             //  4818:      } // switch Inst[7:6]
                                             //  4818:     }
  10, 0,                                     //  4823:     case 0xa: {
  OPC_SwitchField, 6, 2,                     //  4825:      switch Inst[7:6] {
  1, 7,                                      //  4828:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4830:       check predicate 35
  OPC_Decode, 171, 31, 143, 2,               //  4832:       decode to VUZPq32 using decoder 271
                                             //  4832:      }
  3, 0,                                      //  4837:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4839:       check predicate 35
  OPC_Decode, 176, 31, 143, 2,               //  4841:       decode to VZIPq32 using decoder 271
                                             //  4841:      }
                                             //  4841:      } // switch Inst[7:6]
                                             //  4841:     }
                                             //  4841:     } // switch Inst[19:16]
                                             //  4841:    }
  2, 190, 2,                                 //  4846:    case 0x2: {
  OPC_SwitchField, 16, 4,                    //  4849:     switch Inst[19:16] {
  0, 39,                                     //  4852:     case 0x0: {
  OPC_SwitchField, 6, 2,                     //  4854:      switch Inst[7:6] {
  0, 7,                                      //  4857:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4859:       check predicate 35
  OPC_Decode, 214, 24, 140, 2,               //  4861:       decode to VPADDLsv8i8 using decoder 268
                                             //  4861:      }
  1, 7,                                      //  4866:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4868:       check predicate 35
  OPC_Decode, 209, 24, 141, 2,               //  4870:       decode to VPADDLsv16i8 using decoder 269
                                             //  4870:      }
  2, 7,                                      //  4875:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4877:       check predicate 35
  OPC_Decode, 220, 24, 140, 2,               //  4879:       decode to VPADDLuv8i8 using decoder 268
                                             //  4879:      }
  3, 0,                                      //  4884:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4886:       check predicate 35
  OPC_Decode, 215, 24, 141, 2,               //  4888:       decode to VPADDLuv16i8 using decoder 269
                                             //  4888:      }
                                             //  4888:      } // switch Inst[7:6]
                                             //  4888:     }
  1, 21,                                     //  4893:     case 0x1: {
  OPC_SwitchField, 6, 2,                     //  4895:      switch Inst[7:6] {
  0, 7,                                      //  4898:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4900:       check predicate 35
  OPC_Decode, 136, 18, 140, 2,               //  4902:       decode to VCLTzv8i8 using decoder 268
                                             //  4902:      }
  1, 0,                                      //  4907:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4909:       check predicate 35
  OPC_Decode, 255, 17, 141, 2,               //  4911:       decode to VCLTzv16i8 using decoder 269
                                             //  4911:      }
                                             //  4911:      } // switch Inst[7:6]
                                             //  4911:     }
  2, 39,                                     //  4916:     case 0x2: {
  OPC_SwitchField, 6, 2,                     //  4918:      switch Inst[7:6] {
  0, 7,                                      //  4921:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4923:       check predicate 35
  OPC_Decode, 213, 23, 144, 2,               //  4925:       decode to VMOVNv8i8 using decoder 272
                                             //  4925:      }
  1, 7,                                      //  4930:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4932:       check predicate 35
  OPC_Decode, 158, 25, 144, 2,               //  4934:       decode to VQMOVNsuv8i8 using decoder 272
                                             //  4934:      }
  2, 7,                                      //  4939:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4941:       check predicate 35
  OPC_Decode, 161, 25, 144, 2,               //  4943:       decode to VQMOVNsv8i8 using decoder 272
                                             //  4943:      }
  3, 0,                                      //  4948:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4950:       check predicate 35
  OPC_Decode, 164, 25, 144, 2,               //  4952:       decode to VQMOVNuv8i8 using decoder 272
                                             //  4952:      }
                                             //  4952:      } // switch Inst[7:6]
                                             //  4952:     }
  4, 39,                                     //  4957:     case 0x4: {
  OPC_SwitchField, 6, 2,                     //  4959:      switch Inst[7:6] {
  0, 7,                                      //  4962:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  4964:       check predicate 35
  OPC_Decode, 211, 24, 140, 2,               //  4966:       decode to VPADDLsv4i16 using decoder 268
                                             //  4966:      }
  1, 7,                                      //  4971:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  4973:       check predicate 35
  OPC_Decode, 213, 24, 141, 2,               //  4975:       decode to VPADDLsv8i16 using decoder 269
                                             //  4975:      }
  2, 7,                                      //  4980:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  4982:       check predicate 35
  OPC_Decode, 217, 24, 140, 2,               //  4984:       decode to VPADDLuv4i16 using decoder 268
                                             //  4984:      }
  3, 0,                                      //  4989:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  4991:       check predicate 35
  OPC_Decode, 219, 24, 141, 2,               //  4993:       decode to VPADDLuv8i16 using decoder 269
                                             //  4993:      }
                                             //  4993:      } // switch Inst[7:6]
                                             //  4993:     }
  5, 21,                                     //  4998:     case 0x5: {
  OPC_SwitchField, 6, 2,                     //  5000:      switch Inst[7:6] {
  0, 7,                                      //  5003:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5005:       check predicate 35
  OPC_Decode, 132, 18, 140, 2,               //  5007:       decode to VCLTzv4i16 using decoder 268
                                             //  5007:      }
  1, 0,                                      //  5012:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5014:       check predicate 35
  OPC_Decode, 135, 18, 141, 2,               //  5016:       decode to VCLTzv8i16 using decoder 269
                                             //  5016:      }
                                             //  5016:      } // switch Inst[7:6]
                                             //  5016:     }
  6, 39,                                     //  5021:     case 0x6: {
  OPC_SwitchField, 6, 2,                     //  5023:      switch Inst[7:6] {
  0, 7,                                      //  5026:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5028:       check predicate 35
  OPC_Decode, 212, 23, 144, 2,               //  5030:       decode to VMOVNv4i16 using decoder 272
                                             //  5030:      }
  1, 7,                                      //  5035:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5037:       check predicate 35
  OPC_Decode, 157, 25, 144, 2,               //  5039:       decode to VQMOVNsuv4i16 using decoder 272
                                             //  5039:      }
  2, 7,                                      //  5044:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5046:       check predicate 35
  OPC_Decode, 160, 25, 144, 2,               //  5048:       decode to VQMOVNsv4i16 using decoder 272
                                             //  5048:      }
  3, 0,                                      //  5053:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5055:       check predicate 35
  OPC_Decode, 163, 25, 144, 2,               //  5057:       decode to VQMOVNuv4i16 using decoder 272
                                             //  5057:      }
                                             //  5057:      } // switch Inst[7:6]
                                             //  5057:     }
  8, 39,                                     //  5062:     case 0x8: {
  OPC_SwitchField, 6, 2,                     //  5064:      switch Inst[7:6] {
  0, 7,                                      //  5067:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5069:       check predicate 35
  OPC_Decode, 210, 24, 140, 2,               //  5071:       decode to VPADDLsv2i32 using decoder 268
                                             //  5071:      }
  1, 7,                                      //  5076:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5078:       check predicate 35
  OPC_Decode, 212, 24, 141, 2,               //  5080:       decode to VPADDLsv4i32 using decoder 269
                                             //  5080:      }
  2, 7,                                      //  5085:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5087:       check predicate 35
  OPC_Decode, 216, 24, 140, 2,               //  5089:       decode to VPADDLuv2i32 using decoder 268
                                             //  5089:      }
  3, 0,                                      //  5094:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5096:       check predicate 35
  OPC_Decode, 218, 24, 141, 2,               //  5098:       decode to VPADDLuv4i32 using decoder 269
                                             //  5098:      }
                                             //  5098:      } // switch Inst[7:6]
                                             //  5098:     }
  9, 21,                                     //  5103:     case 0x9: {
  OPC_SwitchField, 6, 2,                     //  5105:      switch Inst[7:6] {
  0, 7,                                      //  5108:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5110:       check predicate 35
  OPC_Decode, 129, 18, 140, 2,               //  5112:       decode to VCLTzv2i32 using decoder 268
                                             //  5112:      }
  1, 0,                                      //  5117:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5119:       check predicate 35
  OPC_Decode, 133, 18, 141, 2,               //  5121:       decode to VCLTzv4i32 using decoder 269
                                             //  5121:      }
                                             //  5121:      } // switch Inst[7:6]
                                             //  5121:     }
  10, 0,                                     //  5126:     case 0xa: {
  OPC_SwitchField, 6, 2,                     //  5128:      switch Inst[7:6] {
  0, 7,                                      //  5131:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5133:       check predicate 35
  OPC_Decode, 211, 23, 144, 2,               //  5135:       decode to VMOVNv2i32 using decoder 272
                                             //  5135:      }
  1, 7,                                      //  5140:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5142:       check predicate 35
  OPC_Decode, 156, 25, 144, 2,               //  5144:       decode to VQMOVNsuv2i32 using decoder 272
                                             //  5144:      }
  2, 7,                                      //  5149:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5151:       check predicate 35
  OPC_Decode, 159, 25, 144, 2,               //  5153:       decode to VQMOVNsv2i32 using decoder 272
                                             //  5153:      }
  3, 0,                                      //  5158:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5160:       check predicate 35
  OPC_Decode, 162, 25, 144, 2,               //  5162:       decode to VQMOVNuv2i32 using decoder 272
                                             //  5162:      }
                                             //  5162:      } // switch Inst[7:6]
                                             //  5162:     }
                                             //  5162:     } // switch Inst[19:16]
                                             //  5162:    }
  3, 165, 1,                                 //  5167:    case 0x3: {
  OPC_SwitchField, 16, 4,                    //  5170:     switch Inst[19:16] {
  1, 39,                                     //  5173:     case 0x1: {
  OPC_SwitchField, 6, 2,                     //  5175:      switch Inst[7:6] {
  0, 7,                                      //  5178:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5180:       check predicate 35
  OPC_Decode, 232, 16, 140, 2,               //  5182:       decode to VABSv8i8 using decoder 268
                                             //  5182:      }
  1, 7,                                      //  5187:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5189:       check predicate 35
  OPC_Decode, 227, 16, 141, 2,               //  5191:       decode to VABSv16i8 using decoder 269
                                             //  5191:      }
  2, 7,                                      //  5196:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5198:       check predicate 35
  OPC_Decode, 178, 24, 140, 2,               //  5200:       decode to VNEGs8d using decoder 268
                                             //  5200:      }
  3, 0,                                      //  5205:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5207:       check predicate 35
  OPC_Decode, 179, 24, 141, 2,               //  5209:       decode to VNEGs8q using decoder 269
                                             //  5209:      }
                                             //  5209:      } // switch Inst[7:6]
                                             //  5209:     }
  2, 11,                                     //  5214:     case 0x2: {
  OPC_CheckPredicate, 35,                    //  5216:      check predicate 35
  OPC_CheckField, 6, 2, 0,                   //  5218:      check Inst[7:6] == 0x0
  OPC_Decode, 198, 27, 145, 2,               //  5222:      decode to VSHLLi8 using decoder 273
                                             //  5222:     }
  5, 39,                                     //  5227:     case 0x5: {
  OPC_SwitchField, 6, 2,                     //  5229:      switch Inst[7:6] {
  0, 7,                                      //  5232:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5234:       check predicate 35
  OPC_Decode, 229, 16, 140, 2,               //  5236:       decode to VABSv4i16 using decoder 268
                                             //  5236:      }
  1, 7,                                      //  5241:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5243:       check predicate 35
  OPC_Decode, 231, 16, 141, 2,               //  5245:       decode to VABSv8i16 using decoder 269
                                             //  5245:      }
  2, 7,                                      //  5250:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5252:       check predicate 35
  OPC_Decode, 174, 24, 140, 2,               //  5254:       decode to VNEGs16d using decoder 268
                                             //  5254:      }
  3, 0,                                      //  5259:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5261:       check predicate 35
  OPC_Decode, 175, 24, 141, 2,               //  5263:       decode to VNEGs16q using decoder 269
                                             //  5263:      }
                                             //  5263:      } // switch Inst[7:6]
                                             //  5263:     }
  6, 11,                                     //  5268:     case 0x6: {
  OPC_CheckPredicate, 35,                    //  5270:      check predicate 35
  OPC_CheckField, 6, 2, 0,                   //  5272:      check Inst[7:6] == 0x0
  OPC_Decode, 196, 27, 145, 2,               //  5276:      decode to VSHLLi16 using decoder 273
                                             //  5276:     }
  9, 39,                                     //  5281:     case 0x9: {
  OPC_SwitchField, 6, 2,                     //  5283:      switch Inst[7:6] {
  0, 7,                                      //  5286:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5288:       check predicate 35
  OPC_Decode, 228, 16, 140, 2,               //  5290:       decode to VABSv2i32 using decoder 268
                                             //  5290:      }
  1, 7,                                      //  5295:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5297:       check predicate 35
  OPC_Decode, 230, 16, 141, 2,               //  5299:       decode to VABSv4i32 using decoder 269
                                             //  5299:      }
  2, 7,                                      //  5304:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5306:       check predicate 35
  OPC_Decode, 176, 24, 140, 2,               //  5308:       decode to VNEGs32d using decoder 268
                                             //  5308:      }
  3, 0,                                      //  5313:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5315:       check predicate 35
  OPC_Decode, 177, 24, 141, 2,               //  5317:       decode to VNEGs32q using decoder 269
                                             //  5317:      }
                                             //  5317:      } // switch Inst[7:6]
                                             //  5317:     }
  10, 0,                                     //  5322:     case 0xa: {
  OPC_CheckPredicate, 35,                    //  5324:      check predicate 35
  OPC_CheckField, 6, 2, 0,                   //  5326:      check Inst[7:6] == 0x0
  OPC_Decode, 197, 27, 145, 2,               //  5330:      decode to VSHLLi32 using decoder 273
                                             //  5330:     }
                                             //  5330:     } // switch Inst[19:16]
                                             //  5330:    }
  4, 249, 1,                                 //  5335:    case 0x4: {
  OPC_SwitchField, 16, 4,                    //  5338:     switch Inst[19:16] {
  0, 39,                                     //  5341:     case 0x0: {
  OPC_SwitchField, 6, 2,                     //  5343:      switch Inst[7:6] {
  0, 7,                                      //  5346:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5348:       check predicate 35
  OPC_Decode, 254, 17, 140, 2,               //  5350:       decode to VCLSv8i8 using decoder 268
                                             //  5350:      }
  1, 7,                                      //  5355:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5357:       check predicate 35
  OPC_Decode, 249, 17, 141, 2,               //  5359:       decode to VCLSv16i8 using decoder 269
                                             //  5359:      }
  2, 7,                                      //  5364:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5366:       check predicate 35
  OPC_Decode, 142, 18, 140, 2,               //  5368:       decode to VCLZv8i8 using decoder 268
                                             //  5368:      }
  3, 0,                                      //  5373:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5375:       check predicate 35
  OPC_Decode, 137, 18, 141, 2,               //  5377:       decode to VCLZv16i8 using decoder 269
                                             //  5377:      }
                                             //  5377:      } // switch Inst[7:6]
                                             //  5377:     }
  4, 39,                                     //  5382:     case 0x4: {
  OPC_SwitchField, 6, 2,                     //  5384:      switch Inst[7:6] {
  0, 7,                                      //  5387:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5389:       check predicate 35
  OPC_Decode, 251, 17, 140, 2,               //  5391:       decode to VCLSv4i16 using decoder 268
                                             //  5391:      }
  1, 7,                                      //  5396:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5398:       check predicate 35
  OPC_Decode, 253, 17, 141, 2,               //  5400:       decode to VCLSv8i16 using decoder 269
                                             //  5400:      }
  2, 7,                                      //  5405:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5407:       check predicate 35
  OPC_Decode, 139, 18, 140, 2,               //  5409:       decode to VCLZv4i16 using decoder 268
                                             //  5409:      }
  3, 0,                                      //  5414:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5416:       check predicate 35
  OPC_Decode, 141, 18, 141, 2,               //  5418:       decode to VCLZv8i16 using decoder 269
                                             //  5418:      }
                                             //  5418:      } // switch Inst[7:6]
                                             //  5418:     }
  5, 39,                                     //  5423:     case 0x5: {
  OPC_SwitchField, 6, 2,                     //  5425:      switch Inst[7:6] {
  0, 7,                                      //  5428:      case 0x0: {
  OPC_CheckPredicate, 36,                    //  5430:       check predicate 36
  OPC_Decode, 232, 17, 140, 2,               //  5432:       decode to VCGTzv4f16 using decoder 268
                                             //  5432:      }
  1, 7,                                      //  5437:      case 0x1: {
  OPC_CheckPredicate, 36,                    //  5439:       check predicate 36
  OPC_Decode, 236, 17, 141, 2,               //  5441:       decode to VCGTzv8f16 using decoder 269
                                             //  5441:      }
  2, 7,                                      //  5446:      case 0x2: {
  OPC_CheckPredicate, 36,                    //  5448:       check predicate 36
  OPC_Decode, 206, 17, 140, 2,               //  5450:       decode to VCGEzv4f16 using decoder 268
                                             //  5450:      }
  3, 0,                                      //  5455:      case 0x3: {
  OPC_CheckPredicate, 36,                    //  5457:       check predicate 36
  OPC_Decode, 210, 17, 141, 2,               //  5459:       decode to VCGEzv8f16 using decoder 269
                                             //  5459:      }
                                             //  5459:      } // switch Inst[7:6]
                                             //  5459:     }
  8, 39,                                     //  5464:     case 0x8: {
  OPC_SwitchField, 6, 2,                     //  5466:      switch Inst[7:6] {
  0, 7,                                      //  5469:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5471:       check predicate 35
  OPC_Decode, 250, 17, 140, 2,               //  5473:       decode to VCLSv2i32 using decoder 268
                                             //  5473:      }
  1, 7,                                      //  5478:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5480:       check predicate 35
  OPC_Decode, 252, 17, 141, 2,               //  5482:       decode to VCLSv4i32 using decoder 269
                                             //  5482:      }
  2, 7,                                      //  5487:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5489:       check predicate 35
  OPC_Decode, 138, 18, 140, 2,               //  5491:       decode to VCLZv2i32 using decoder 268
                                             //  5491:      }
  3, 0,                                      //  5496:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5498:       check predicate 35
  OPC_Decode, 140, 18, 141, 2,               //  5500:       decode to VCLZv4i32 using decoder 269
                                             //  5500:      }
                                             //  5500:      } // switch Inst[7:6]
                                             //  5500:     }
  9, 39,                                     //  5505:     case 0x9: {
  OPC_SwitchField, 6, 2,                     //  5507:      switch Inst[7:6] {
  0, 7,                                      //  5510:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5512:       check predicate 35
  OPC_Decode, 230, 17, 140, 2,               //  5514:       decode to VCGTzv2f32 using decoder 268
                                             //  5514:      }
  1, 7,                                      //  5519:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5521:       check predicate 35
  OPC_Decode, 233, 17, 141, 2,               //  5523:       decode to VCGTzv4f32 using decoder 269
                                             //  5523:      }
  2, 7,                                      //  5528:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5530:       check predicate 35
  OPC_Decode, 204, 17, 140, 2,               //  5532:       decode to VCGEzv2f32 using decoder 268
                                             //  5532:      }
  3, 0,                                      //  5537:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5539:       check predicate 35
  OPC_Decode, 207, 17, 141, 2,               //  5541:       decode to VCGEzv4f32 using decoder 269
                                             //  5541:      }
                                             //  5541:      } // switch Inst[7:6]
                                             //  5541:     }
  11, 0,                                     //  5546:     case 0xb: {
  OPC_SwitchField, 6, 2,                     //  5548:      switch Inst[7:6] {
  0, 7,                                      //  5551:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5553:       check predicate 35
  OPC_Decode, 160, 26, 140, 2,               //  5555:       decode to VRECPEd using decoder 268
                                             //  5555:      }
  1, 7,                                      //  5560:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5562:       check predicate 35
  OPC_Decode, 165, 26, 141, 2,               //  5564:       decode to VRECPEq using decoder 269
                                             //  5564:      }
  2, 7,                                      //  5569:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5571:       check predicate 35
  OPC_Decode, 146, 27, 140, 2,               //  5573:       decode to VRSQRTEd using decoder 268
                                             //  5573:      }
  3, 0,                                      //  5578:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5580:       check predicate 35
  OPC_Decode, 151, 27, 141, 2,               //  5582:       decode to VRSQRTEq using decoder 269
                                             //  5582:      }
                                             //  5582:      } // switch Inst[7:6]
                                             //  5582:     }
                                             //  5582:     } // switch Inst[19:16]
                                             //  5582:    }
  5, 208, 1,                                 //  5587:    case 0x5: {
  OPC_SwitchField, 16, 4,                    //  5590:     switch Inst[19:16] {
  0, 39,                                     //  5593:     case 0x0: {
  OPC_SwitchField, 6, 2,                     //  5595:      switch Inst[7:6] {
  0, 7,                                      //  5598:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5600:       check predicate 35
  OPC_Decode, 163, 18, 140, 2,               //  5602:       decode to VCNTd using decoder 268
                                             //  5602:      }
  1, 7,                                      //  5607:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5609:       check predicate 35
  OPC_Decode, 164, 18, 141, 2,               //  5611:       decode to VCNTq using decoder 269
                                             //  5611:      }
  2, 7,                                      //  5616:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5618:       check predicate 35
  OPC_Decode, 161, 24, 140, 2,               //  5620:       decode to VMVNd using decoder 268
                                             //  5620:      }
  3, 0,                                      //  5625:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5627:       check predicate 35
  OPC_Decode, 162, 24, 141, 2,               //  5629:       decode to VMVNq using decoder 269
                                             //  5629:      }
                                             //  5629:      } // switch Inst[7:6]
                                             //  5629:     }
  5, 39,                                     //  5634:     case 0x5: {
  OPC_SwitchField, 6, 2,                     //  5636:      switch Inst[7:6] {
  0, 7,                                      //  5639:      case 0x0: {
  OPC_CheckPredicate, 36,                    //  5641:       check predicate 36
  OPC_Decode, 180, 17, 140, 2,               //  5643:       decode to VCEQzv4f16 using decoder 268
                                             //  5643:      }
  1, 7,                                      //  5648:      case 0x1: {
  OPC_CheckPredicate, 36,                    //  5650:       check predicate 36
  OPC_Decode, 184, 17, 141, 2,               //  5652:       decode to VCEQzv8f16 using decoder 269
                                             //  5652:      }
  2, 7,                                      //  5657:      case 0x2: {
  OPC_CheckPredicate, 36,                    //  5659:       check predicate 36
  OPC_Decode, 242, 17, 140, 2,               //  5661:       decode to VCLEzv4f16 using decoder 268
                                             //  5661:      }
  3, 0,                                      //  5666:      case 0x3: {
  OPC_CheckPredicate, 36,                    //  5668:       check predicate 36
  OPC_Decode, 246, 17, 141, 2,               //  5670:       decode to VCLEzv8f16 using decoder 269
                                             //  5670:      }
                                             //  5670:      } // switch Inst[7:6]
                                             //  5670:     }
  7, 39,                                     //  5675:     case 0x7: {
  OPC_SwitchField, 6, 2,                     //  5677:      switch Inst[7:6] {
  0, 7,                                      //  5680:      case 0x0: {
  OPC_CheckPredicate, 36,                    //  5682:       check predicate 36
  OPC_Decode, 163, 26, 140, 2,               //  5684:       decode to VRECPEhd using decoder 268
                                             //  5684:      }
  1, 7,                                      //  5689:      case 0x1: {
  OPC_CheckPredicate, 36,                    //  5691:       check predicate 36
  OPC_Decode, 164, 26, 141, 2,               //  5693:       decode to VRECPEhq using decoder 269
                                             //  5693:      }
  2, 7,                                      //  5698:      case 0x2: {
  OPC_CheckPredicate, 36,                    //  5700:       check predicate 36
  OPC_Decode, 149, 27, 140, 2,               //  5702:       decode to VRSQRTEhd using decoder 268
                                             //  5702:      }
  3, 0,                                      //  5707:      case 0x3: {
  OPC_CheckPredicate, 36,                    //  5709:       check predicate 36
  OPC_Decode, 150, 27, 141, 2,               //  5711:       decode to VRSQRTEhq using decoder 269
                                             //  5711:      }
                                             //  5711:      } // switch Inst[7:6]
                                             //  5711:     }
  9, 39,                                     //  5716:     case 0x9: {
  OPC_SwitchField, 6, 2,                     //  5718:      switch Inst[7:6] {
  0, 7,                                      //  5721:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5723:       check predicate 35
  OPC_Decode, 178, 17, 140, 2,               //  5725:       decode to VCEQzv2f32 using decoder 268
                                             //  5725:      }
  1, 7,                                      //  5730:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5732:       check predicate 35
  OPC_Decode, 181, 17, 141, 2,               //  5734:       decode to VCEQzv4f32 using decoder 269
                                             //  5734:      }
  2, 7,                                      //  5739:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5741:       check predicate 35
  OPC_Decode, 240, 17, 140, 2,               //  5743:       decode to VCLEzv2f32 using decoder 268
                                             //  5743:      }
  3, 0,                                      //  5748:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5750:       check predicate 35
  OPC_Decode, 243, 17, 141, 2,               //  5752:       decode to VCLEzv4f32 using decoder 269
                                             //  5752:      }
                                             //  5752:      } // switch Inst[7:6]
                                             //  5752:     }
  11, 0,                                     //  5757:     case 0xb: {
  OPC_SwitchField, 6, 2,                     //  5759:      switch Inst[7:6] {
  0, 7,                                      //  5762:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5764:       check predicate 35
  OPC_Decode, 161, 26, 140, 2,               //  5766:       decode to VRECPEfd using decoder 268
                                             //  5766:      }
  1, 7,                                      //  5771:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5773:       check predicate 35
  OPC_Decode, 162, 26, 141, 2,               //  5775:       decode to VRECPEfq using decoder 269
                                             //  5775:      }
  2, 7,                                      //  5780:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5782:       check predicate 35
  OPC_Decode, 147, 27, 140, 2,               //  5784:       decode to VRSQRTEfd using decoder 268
                                             //  5784:      }
  3, 0,                                      //  5789:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5791:       check predicate 35
  OPC_Decode, 148, 27, 141, 2,               //  5793:       decode to VRSQRTEfq using decoder 269
                                             //  5793:      }
                                             //  5793:      } // switch Inst[7:6]
                                             //  5793:     }
                                             //  5793:     } // switch Inst[19:16]
                                             //  5793:    }
  6, 149, 2,                                 //  5798:    case 0x6: {
  OPC_SwitchField, 16, 4,                    //  5801:     switch Inst[19:16] {
  0, 39,                                     //  5804:     case 0x0: {
  OPC_SwitchField, 6, 2,                     //  5806:      switch Inst[7:6] {
  0, 7,                                      //  5809:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5811:       check predicate 35
  OPC_Decode, 202, 24, 146, 2,               //  5813:       decode to VPADALsv8i8 using decoder 274
                                             //  5813:      }
  1, 7,                                      //  5818:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5820:       check predicate 35
  OPC_Decode, 197, 24, 147, 2,               //  5822:       decode to VPADALsv16i8 using decoder 275
                                             //  5822:      }
  2, 7,                                      //  5827:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5829:       check predicate 35
  OPC_Decode, 208, 24, 146, 2,               //  5831:       decode to VPADALuv8i8 using decoder 274
                                             //  5831:      }
  3, 0,                                      //  5836:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5838:       check predicate 35
  OPC_Decode, 203, 24, 147, 2,               //  5840:       decode to VPADALuv16i8 using decoder 275
                                             //  5840:      }
                                             //  5840:      } // switch Inst[7:6]
                                             //  5840:     }
  4, 39,                                     //  5845:     case 0x4: {
  OPC_SwitchField, 6, 2,                     //  5847:      switch Inst[7:6] {
  0, 7,                                      //  5850:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5852:       check predicate 35
  OPC_Decode, 199, 24, 146, 2,               //  5854:       decode to VPADALsv4i16 using decoder 274
                                             //  5854:      }
  1, 7,                                      //  5859:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5861:       check predicate 35
  OPC_Decode, 201, 24, 147, 2,               //  5863:       decode to VPADALsv8i16 using decoder 275
                                             //  5863:      }
  2, 7,                                      //  5868:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5870:       check predicate 35
  OPC_Decode, 205, 24, 146, 2,               //  5872:       decode to VPADALuv4i16 using decoder 274
                                             //  5872:      }
  3, 0,                                      //  5877:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  5879:       check predicate 35
  OPC_Decode, 207, 24, 147, 2,               //  5881:       decode to VPADALuv8i16 using decoder 275
                                             //  5881:      }
                                             //  5881:      } // switch Inst[7:6]
                                             //  5881:     }
  5, 21,                                     //  5886:     case 0x5: {
  OPC_SwitchField, 6, 2,                     //  5888:      switch Inst[7:6] {
  0, 7,                                      //  5891:      case 0x0: {
  OPC_CheckPredicate, 36,                    //  5893:       check predicate 36
  OPC_Decode, 130, 18, 140, 2,               //  5895:       decode to VCLTzv4f16 using decoder 268
                                             //  5895:      }
  1, 0,                                      //  5900:      case 0x1: {
  OPC_CheckPredicate, 36,                    //  5902:       check predicate 36
  OPC_Decode, 134, 18, 141, 2,               //  5904:       decode to VCLTzv8f16 using decoder 269
                                             //  5904:      }
                                             //  5904:      } // switch Inst[7:6]
                                             //  5904:     }
  6, 21,                                     //  5909:     case 0x6: {
  OPC_SwitchField, 6, 2,                     //  5911:      switch Inst[7:6] {
  0, 7,                                      //  5914:      case 0x0: {
  OPC_CheckPredicate, 39,                    //  5916:       check predicate 39
  OPC_Decode, 231, 18, 144, 2,               //  5918:       decode to VCVTf2h using decoder 272
                                             //  5918:      }
  1, 0,                                      //  5923:      case 0x1: {
  OPC_CheckPredicate, 40,                    //  5925:       check predicate 40
  OPC_Decode, 182, 6, 144, 2,                //  5927:       decode to BF16_VCVT using decoder 272
                                             //  5927:      }
                                             //  5927:      } // switch Inst[7:6]
                                             //  5927:     }
  7, 39,                                     //  5932:     case 0x7: {
  OPC_SwitchField, 6, 2,                     //  5934:      switch Inst[7:6] {
  0, 7,                                      //  5937:      case 0x0: {
  OPC_CheckPredicate, 36,                    //  5939:       check predicate 36
  OPC_Decode, 251, 18, 140, 2,               //  5941:       decode to VCVTs2hd using decoder 268
                                             //  5941:      }
  1, 7,                                      //  5946:      case 0x1: {
  OPC_CheckPredicate, 36,                    //  5948:       check predicate 36
  OPC_Decode, 252, 18, 141, 2,               //  5950:       decode to VCVTs2hq using decoder 269
                                             //  5950:      }
  2, 7,                                      //  5955:      case 0x2: {
  OPC_CheckPredicate, 36,                    //  5957:       check predicate 36
  OPC_Decode, 255, 18, 140, 2,               //  5959:       decode to VCVTu2hd using decoder 268
                                             //  5959:      }
  3, 0,                                      //  5964:      case 0x3: {
  OPC_CheckPredicate, 36,                    //  5966:       check predicate 36
  OPC_Decode, 128, 19, 141, 2,               //  5968:       decode to VCVTu2hq using decoder 269
                                             //  5968:      }
                                             //  5968:      } // switch Inst[7:6]
                                             //  5968:     }
  8, 39,                                     //  5973:     case 0x8: {
  OPC_SwitchField, 6, 2,                     //  5975:      switch Inst[7:6] {
  0, 7,                                      //  5978:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  5980:       check predicate 35
  OPC_Decode, 198, 24, 146, 2,               //  5982:       decode to VPADALsv2i32 using decoder 274
                                             //  5982:      }
  1, 7,                                      //  5987:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  5989:       check predicate 35
  OPC_Decode, 200, 24, 147, 2,               //  5991:       decode to VPADALsv4i32 using decoder 275
                                             //  5991:      }
  2, 7,                                      //  5996:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  5998:       check predicate 35
  OPC_Decode, 204, 24, 146, 2,               //  6000:       decode to VPADALuv2i32 using decoder 274
                                             //  6000:      }
  3, 0,                                      //  6005:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  6007:       check predicate 35
  OPC_Decode, 206, 24, 147, 2,               //  6009:       decode to VPADALuv4i32 using decoder 275
                                             //  6009:      }
                                             //  6009:      } // switch Inst[7:6]
                                             //  6009:     }
  9, 21,                                     //  6014:     case 0x9: {
  OPC_SwitchField, 6, 2,                     //  6016:      switch Inst[7:6] {
  0, 7,                                      //  6019:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  6021:       check predicate 35
  OPC_Decode, 128, 18, 140, 2,               //  6023:       decode to VCLTzv2f32 using decoder 268
                                             //  6023:      }
  1, 0,                                      //  6028:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  6030:       check predicate 35
  OPC_Decode, 131, 18, 141, 2,               //  6032:       decode to VCLTzv4f32 using decoder 269
                                             //  6032:      }
                                             //  6032:      } // switch Inst[7:6]
                                             //  6032:     }
  11, 0,                                     //  6037:     case 0xb: {
  OPC_SwitchField, 6, 2,                     //  6039:      switch Inst[7:6] {
  0, 7,                                      //  6042:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  6044:       check predicate 35
  OPC_Decode, 249, 18, 140, 2,               //  6046:       decode to VCVTs2fd using decoder 268
                                             //  6046:      }
  1, 7,                                      //  6051:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  6053:       check predicate 35
  OPC_Decode, 250, 18, 141, 2,               //  6055:       decode to VCVTs2fq using decoder 269
                                             //  6055:      }
  2, 7,                                      //  6060:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  6062:       check predicate 35
  OPC_Decode, 253, 18, 140, 2,               //  6064:       decode to VCVTu2fd using decoder 268
                                             //  6064:      }
  3, 0,                                      //  6069:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  6071:       check predicate 35
  OPC_Decode, 254, 18, 141, 2,               //  6073:       decode to VCVTu2fq using decoder 269
                                             //  6073:      }
                                             //  6073:      } // switch Inst[7:6]
                                             //  6073:     }
                                             //  6073:     } // switch Inst[19:16]
                                             //  6073:    }
  7, 175, 2,                                 //  6078:    case 0x7: {
  OPC_SwitchField, 16, 4,                    //  6081:     switch Inst[19:16] {
  0, 39,                                     //  6084:     case 0x0: {
  OPC_SwitchField, 6, 2,                     //  6086:      switch Inst[7:6] {
  0, 7,                                      //  6089:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  6091:       check predicate 35
  OPC_Decode, 247, 24, 140, 2,               //  6093:       decode to VQABSv8i8 using decoder 268
                                             //  6093:      }
  1, 7,                                      //  6098:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  6100:       check predicate 35
  OPC_Decode, 242, 24, 141, 2,               //  6102:       decode to VQABSv16i8 using decoder 269
                                             //  6102:      }
  2, 7,                                      //  6107:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  6109:       check predicate 35
  OPC_Decode, 170, 25, 140, 2,               //  6111:       decode to VQNEGv8i8 using decoder 268
                                             //  6111:      }
  3, 0,                                      //  6116:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  6118:       check predicate 35
  OPC_Decode, 165, 25, 141, 2,               //  6120:       decode to VQNEGv16i8 using decoder 269
                                             //  6120:      }
                                             //  6120:      } // switch Inst[7:6]
                                             //  6120:     }
  4, 39,                                     //  6125:     case 0x4: {
  OPC_SwitchField, 6, 2,                     //  6127:      switch Inst[7:6] {
  0, 7,                                      //  6130:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  6132:       check predicate 35
  OPC_Decode, 244, 24, 140, 2,               //  6134:       decode to VQABSv4i16 using decoder 268
                                             //  6134:      }
  1, 7,                                      //  6139:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  6141:       check predicate 35
  OPC_Decode, 246, 24, 141, 2,               //  6143:       decode to VQABSv8i16 using decoder 269
                                             //  6143:      }
  2, 7,                                      //  6148:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  6150:       check predicate 35
  OPC_Decode, 167, 25, 140, 2,               //  6152:       decode to VQNEGv4i16 using decoder 268
                                             //  6152:      }
  3, 0,                                      //  6157:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  6159:       check predicate 35
  OPC_Decode, 169, 25, 141, 2,               //  6161:       decode to VQNEGv8i16 using decoder 269
                                             //  6161:      }
                                             //  6161:      } // switch Inst[7:6]
                                             //  6161:     }
  5, 39,                                     //  6166:     case 0x5: {
  OPC_SwitchField, 6, 2,                     //  6168:      switch Inst[7:6] {
  0, 7,                                      //  6171:      case 0x0: {
  OPC_CheckPredicate, 36,                    //  6173:       check predicate 36
  OPC_Decode, 225, 16, 140, 2,               //  6175:       decode to VABShd using decoder 268
                                             //  6175:      }
  1, 7,                                      //  6180:      case 0x1: {
  OPC_CheckPredicate, 36,                    //  6182:       check predicate 36
  OPC_Decode, 226, 16, 141, 2,               //  6184:       decode to VABShq using decoder 269
                                             //  6184:      }
  2, 7,                                      //  6189:      case 0x2: {
  OPC_CheckPredicate, 36,                    //  6191:       check predicate 36
  OPC_Decode, 172, 24, 140, 2,               //  6193:       decode to VNEGhd using decoder 268
                                             //  6193:      }
  3, 0,                                      //  6198:      case 0x3: {
  OPC_CheckPredicate, 36,                    //  6200:       check predicate 36
  OPC_Decode, 173, 24, 141, 2,               //  6202:       decode to VNEGhq using decoder 269
                                             //  6202:      }
                                             //  6202:      } // switch Inst[7:6]
                                             //  6202:     }
  6, 11,                                     //  6207:     case 0x6: {
  OPC_CheckPredicate, 39,                    //  6209:      check predicate 39
  OPC_CheckField, 6, 2, 0,                   //  6211:      check Inst[7:6] == 0x0
  OPC_Decode, 240, 18, 148, 2,               //  6215:      decode to VCVTh2f using decoder 276
                                             //  6215:     }
  7, 39,                                     //  6220:     case 0x7: {
  OPC_SwitchField, 6, 2,                     //  6222:      switch Inst[7:6] {
  0, 7,                                      //  6225:      case 0x0: {
  OPC_CheckPredicate, 36,                    //  6227:       check predicate 36
  OPC_Decode, 241, 18, 140, 2,               //  6229:       decode to VCVTh2sd using decoder 268
                                             //  6229:      }
  1, 7,                                      //  6234:      case 0x1: {
  OPC_CheckPredicate, 36,                    //  6236:       check predicate 36
  OPC_Decode, 242, 18, 141, 2,               //  6238:       decode to VCVTh2sq using decoder 269
                                             //  6238:      }
  2, 7,                                      //  6243:      case 0x2: {
  OPC_CheckPredicate, 36,                    //  6245:       check predicate 36
  OPC_Decode, 243, 18, 140, 2,               //  6247:       decode to VCVTh2ud using decoder 268
                                             //  6247:      }
  3, 0,                                      //  6252:      case 0x3: {
  OPC_CheckPredicate, 36,                    //  6254:       check predicate 36
  OPC_Decode, 244, 18, 141, 2,               //  6256:       decode to VCVTh2uq using decoder 269
                                             //  6256:      }
                                             //  6256:      } // switch Inst[7:6]
                                             //  6256:     }
  8, 39,                                     //  6261:     case 0x8: {
  OPC_SwitchField, 6, 2,                     //  6263:      switch Inst[7:6] {
  0, 7,                                      //  6266:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  6268:       check predicate 35
  OPC_Decode, 243, 24, 140, 2,               //  6270:       decode to VQABSv2i32 using decoder 268
                                             //  6270:      }
  1, 7,                                      //  6275:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  6277:       check predicate 35
  OPC_Decode, 245, 24, 141, 2,               //  6279:       decode to VQABSv4i32 using decoder 269
                                             //  6279:      }
  2, 7,                                      //  6284:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  6286:       check predicate 35
  OPC_Decode, 166, 25, 140, 2,               //  6288:       decode to VQNEGv2i32 using decoder 268
                                             //  6288:      }
  3, 0,                                      //  6293:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  6295:       check predicate 35
  OPC_Decode, 168, 25, 141, 2,               //  6297:       decode to VQNEGv4i32 using decoder 269
                                             //  6297:      }
                                             //  6297:      } // switch Inst[7:6]
                                             //  6297:     }
  9, 39,                                     //  6302:     case 0x9: {
  OPC_SwitchField, 6, 2,                     //  6304:      switch Inst[7:6] {
  0, 7,                                      //  6307:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  6309:       check predicate 35
  OPC_Decode, 223, 16, 140, 2,               //  6311:       decode to VABSfd using decoder 268
                                             //  6311:      }
  1, 7,                                      //  6316:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  6318:       check predicate 35
  OPC_Decode, 224, 16, 141, 2,               //  6320:       decode to VABSfq using decoder 269
                                             //  6320:      }
  2, 7,                                      //  6325:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  6327:       check predicate 35
  OPC_Decode, 171, 24, 140, 2,               //  6329:       decode to VNEGfd using decoder 268
                                             //  6329:      }
  3, 0,                                      //  6334:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  6336:       check predicate 35
  OPC_Decode, 170, 24, 141, 2,               //  6338:       decode to VNEGf32q using decoder 269
                                             //  6338:      }
                                             //  6338:      } // switch Inst[7:6]
                                             //  6338:     }
  11, 0,                                     //  6343:     case 0xb: {
  OPC_SwitchField, 6, 2,                     //  6345:      switch Inst[7:6] {
  0, 7,                                      //  6348:      case 0x0: {
  OPC_CheckPredicate, 35,                    //  6350:       check predicate 35
  OPC_Decode, 232, 18, 140, 2,               //  6352:       decode to VCVTf2sd using decoder 268
                                             //  6352:      }
  1, 7,                                      //  6357:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  6359:       check predicate 35
  OPC_Decode, 233, 18, 141, 2,               //  6361:       decode to VCVTf2sq using decoder 269
                                             //  6361:      }
  2, 7,                                      //  6366:      case 0x2: {
  OPC_CheckPredicate, 35,                    //  6368:       check predicate 35
  OPC_Decode, 234, 18, 140, 2,               //  6370:       decode to VCVTf2ud using decoder 268
                                             //  6370:      }
  3, 0,                                      //  6375:      case 0x3: {
  OPC_CheckPredicate, 35,                    //  6377:       check predicate 35
  OPC_Decode, 235, 18, 141, 2,               //  6379:       decode to VCVTf2uq using decoder 269
                                             //  6379:      }
                                             //  6379:      } // switch Inst[7:6]
                                             //  6379:     }
                                             //  6379:     } // switch Inst[19:16]
                                             //  6379:    }
  8, 21,                                     //  6384:    case 0x8: {
  OPC_SwitchField, 6, 1,                     //  6386:     switch Inst[6] {
  0, 7,                                      //  6389:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  6391:      check predicate 35
  OPC_Decode, 229, 30, 149, 2,               //  6393:      decode to VTBL1 using decoder 277
                                             //  6393:     }
  1, 0,                                      //  6398:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  6400:      check predicate 35
  OPC_Decode, 235, 30, 149, 2,               //  6402:      decode to VTBX1 using decoder 277
                                             //  6402:     }
                                             //  6402:     } // switch Inst[6]
                                             //  6402:    }
  9, 21,                                     //  6407:    case 0x9: {
  OPC_SwitchField, 6, 1,                     //  6409:     switch Inst[6] {
  0, 7,                                      //  6412:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  6414:      check predicate 35
  OPC_Decode, 230, 30, 149, 2,               //  6416:      decode to VTBL2 using decoder 277
                                             //  6416:     }
  1, 0,                                      //  6421:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  6423:      check predicate 35
  OPC_Decode, 236, 30, 149, 2,               //  6425:      decode to VTBX2 using decoder 277
                                             //  6425:     }
                                             //  6425:     } // switch Inst[6]
                                             //  6425:    }
  10, 21,                                    //  6430:    case 0xa: {
  OPC_SwitchField, 6, 1,                     //  6432:     switch Inst[6] {
  0, 7,                                      //  6435:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  6437:      check predicate 35
  OPC_Decode, 231, 30, 149, 2,               //  6439:      decode to VTBL3 using decoder 277
                                             //  6439:     }
  1, 0,                                      //  6444:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  6446:      check predicate 35
  OPC_Decode, 237, 30, 149, 2,               //  6448:      decode to VTBX3 using decoder 277
                                             //  6448:     }
                                             //  6448:     } // switch Inst[6]
                                             //  6448:    }
  11, 21,                                    //  6453:    case 0xb: {
  OPC_SwitchField, 6, 1,                     //  6455:     switch Inst[6] {
  0, 7,                                      //  6458:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  6460:      check predicate 35
  OPC_Decode, 233, 30, 149, 2,               //  6462:      decode to VTBL4 using decoder 277
                                             //  6462:     }
  1, 0,                                      //  6467:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  6469:      check predicate 35
  OPC_Decode, 239, 30, 149, 2,               //  6471:      decode to VTBX4 using decoder 277
                                             //  6471:     }
                                             //  6471:     } // switch Inst[6]
                                             //  6471:    }
  12, 0,                                     //  6476:    case 0xc: {
  OPC_SwitchField, 6, 2,                     //  6478:     switch Inst[7:6] {
  0, 39,                                     //  6481:     case 0x0: {
  OPC_SwitchField, 16, 1,                    //  6483:      switch Inst[16] {
  0, 25,                                     //  6486:      case 0x0: {
  OPC_SwitchField, 17, 1,                    //  6488:       switch Inst[17] {
  0, 11,                                     //  6491:       case 0x0: {
  OPC_CheckPredicate, 35,                    //  6493:        check predicate 35
  OPC_CheckField, 18, 1, 1,                  //  6495:        check Inst[18] == 0x1
  OPC_Decode, 148, 19, 150, 2,               //  6499:        decode to VDUPLN32d using decoder 278
                                             //  6499:       }
  1, 0,                                      //  6504:       case 0x1: {
  OPC_CheckPredicate, 35,                    //  6506:        check predicate 35
  OPC_Decode, 146, 19, 151, 2,               //  6508:        decode to VDUPLN16d using decoder 279
                                             //  6508:       }
                                             //  6508:       } // switch Inst[17]
                                             //  6508:      }
  1, 0,                                      //  6513:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  6515:       check predicate 35
  OPC_Decode, 150, 19, 152, 2,               //  6517:       decode to VDUPLN8d using decoder 280
                                             //  6517:      }
                                             //  6517:      } // switch Inst[16]
                                             //  6517:     }
  1, 0,                                      //  6522:     case 0x1: {
  OPC_SwitchField, 16, 1,                    //  6524:      switch Inst[16] {
  0, 25,                                     //  6527:      case 0x0: {
  OPC_SwitchField, 17, 1,                    //  6529:       switch Inst[17] {
  0, 11,                                     //  6532:       case 0x0: {
  OPC_CheckPredicate, 35,                    //  6534:        check predicate 35
  OPC_CheckField, 18, 1, 1,                  //  6536:        check Inst[18] == 0x1
  OPC_Decode, 149, 19, 153, 2,               //  6540:        decode to VDUPLN32q using decoder 281
                                             //  6540:       }
  1, 0,                                      //  6545:       case 0x1: {
  OPC_CheckPredicate, 35,                    //  6547:        check predicate 35
  OPC_Decode, 147, 19, 154, 2,               //  6549:        decode to VDUPLN16q using decoder 282
                                             //  6549:       }
                                             //  6549:       } // switch Inst[17]
                                             //  6549:      }
  1, 0,                                      //  6554:      case 0x1: {
  OPC_CheckPredicate, 35,                    //  6556:       check predicate 35
  OPC_Decode, 151, 19, 155, 2,               //  6558:       decode to VDUPLN8q using decoder 283
                                             //  6558:      }
                                             //  6558:      } // switch Inst[16]
                                             //  6558:     }
                                             //  6558:     } // switch Inst[7:6]
                                             //  6558:    }
                                             //  6558:    } // switch Inst[11:8]
                                             //  6558:   }
                                             //  6558:   } // switch Inst[31:23]
                                             //  6558:  }
                                             //  6558:  } // switch Inst[21:20]
                                             //  6558: }
  1, 0,                                      //  6563: case 0x1: {
  OPC_SwitchField, 6, 1,                     //  6565:  switch Inst[6] {
  0, 217, 21,                                //  6568:  case 0x0: {
  OPC_SwitchField, 23, 1,                    //  6571:   switch Inst[23] {
  0, 191, 10,                                //  6574:   case 0x0: {
  OPC_SwitchField, 8, 4,                     //  6577:    switch Inst[11:8] {
  0, 103,                                    //  6580:    case 0x0: {
  OPC_SwitchField, 20, 2,                    //  6582:     switch Inst[21:20] {
  0, 23,                                     //  6585:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  6587:      switch Inst[31:24] {
  242, 1, 7,                                 //  6590:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6593:       check predicate 35
  OPC_Decode, 255, 24, 238, 1,               //  6595:       decode to VQADDsv8i8 using decoder 238
                                             //  6595:      }
  243, 1, 0,                                 //  6600:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6603:       check predicate 35
  OPC_Decode, 135, 25, 238, 1,               //  6605:       decode to VQADDuv8i8 using decoder 238
                                             //  6605:      }
                                             //  6605:      } // switch Inst[31:24]
                                             //  6605:     }
  1, 23,                                     //  6610:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  6612:      switch Inst[31:24] {
  242, 1, 7,                                 //  6615:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6618:       check predicate 35
  OPC_Decode, 252, 24, 238, 1,               //  6620:       decode to VQADDsv4i16 using decoder 238
                                             //  6620:      }
  243, 1, 0,                                 //  6625:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6628:       check predicate 35
  OPC_Decode, 132, 25, 238, 1,               //  6630:       decode to VQADDuv4i16 using decoder 238
                                             //  6630:      }
                                             //  6630:      } // switch Inst[31:24]
                                             //  6630:     }
  2, 23,                                     //  6635:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  6637:      switch Inst[31:24] {
  242, 1, 7,                                 //  6640:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6643:       check predicate 35
  OPC_Decode, 250, 24, 238, 1,               //  6645:       decode to VQADDsv2i32 using decoder 238
                                             //  6645:      }
  243, 1, 0,                                 //  6650:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6653:       check predicate 35
  OPC_Decode, 130, 25, 238, 1,               //  6655:       decode to VQADDuv2i32 using decoder 238
                                             //  6655:      }
                                             //  6655:      } // switch Inst[31:24]
                                             //  6655:     }
  3, 0,                                      //  6660:     case 0x3: {
  OPC_SwitchField, 24, 8,                    //  6662:      switch Inst[31:24] {
  242, 1, 7,                                 //  6665:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6668:       check predicate 35
  OPC_Decode, 249, 24, 238, 1,               //  6670:       decode to VQADDsv1i64 using decoder 238
                                             //  6670:      }
  243, 1, 0,                                 //  6675:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6678:       check predicate 35
  OPC_Decode, 129, 25, 238, 1,               //  6680:       decode to VQADDuv1i64 using decoder 238
                                             //  6680:      }
                                             //  6680:      } // switch Inst[31:24]
                                             //  6680:     }
                                             //  6680:     } // switch Inst[21:20]
                                             //  6680:    }
  1, 103,                                    //  6685:    case 0x1: {
  OPC_SwitchField, 20, 2,                    //  6687:     switch Inst[21:20] {
  0, 23,                                     //  6690:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  6692:      switch Inst[31:24] {
  242, 1, 7,                                 //  6695:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6698:       check predicate 35
  OPC_Decode, 143, 17, 238, 1,               //  6700:       decode to VANDd using decoder 238
                                             //  6700:      }
  243, 1, 0,                                 //  6705:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6708:       check predicate 35
  OPC_Decode, 152, 19, 238, 1,               //  6710:       decode to VEORd using decoder 238
                                             //  6710:      }
                                             //  6710:      } // switch Inst[31:24]
                                             //  6710:     }
  1, 23,                                     //  6715:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  6717:      switch Inst[31:24] {
  242, 1, 7,                                 //  6720:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6723:       check predicate 35
  OPC_Decode, 149, 17, 238, 1,               //  6725:       decode to VBICd using decoder 238
                                             //  6725:      }
  243, 1, 0,                                 //  6730:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6733:       check predicate 35
  OPC_Decode, 159, 17, 246, 1,               //  6735:       decode to VBSLd using decoder 246
                                             //  6735:      }
                                             //  6735:      } // switch Inst[31:24]
                                             //  6735:     }
  2, 23,                                     //  6740:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  6742:      switch Inst[31:24] {
  242, 1, 7,                                 //  6745:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6748:       check predicate 35
  OPC_Decode, 191, 24, 238, 1,               //  6750:       decode to VORRd using decoder 238
                                             //  6750:      }
  243, 1, 0,                                 //  6755:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6758:       check predicate 35
  OPC_Decode, 157, 17, 246, 1,               //  6760:       decode to VBITd using decoder 246
                                             //  6760:      }
                                             //  6760:      } // switch Inst[31:24]
                                             //  6760:     }
  3, 0,                                      //  6765:     case 0x3: {
  OPC_SwitchField, 24, 8,                    //  6767:      switch Inst[31:24] {
  242, 1, 7,                                 //  6770:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6773:       check predicate 35
  OPC_Decode, 189, 24, 238, 1,               //  6775:       decode to VORNd using decoder 238
                                             //  6775:      }
  243, 1, 0,                                 //  6780:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6783:       check predicate 35
  OPC_Decode, 155, 17, 246, 1,               //  6785:       decode to VBIFd using decoder 246
                                             //  6785:      }
                                             //  6785:      } // switch Inst[31:24]
                                             //  6785:     }
                                             //  6785:     } // switch Inst[21:20]
                                             //  6785:    }
  2, 103,                                    //  6790:    case 0x2: {
  OPC_SwitchField, 20, 2,                    //  6792:     switch Inst[21:20] {
  0, 23,                                     //  6795:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  6797:      switch Inst[31:24] {
  242, 1, 7,                                 //  6800:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6803:       check predicate 35
  OPC_Decode, 148, 26, 238, 1,               //  6805:       decode to VQSUBsv8i8 using decoder 238
                                             //  6805:      }
  243, 1, 0,                                 //  6810:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6813:       check predicate 35
  OPC_Decode, 156, 26, 238, 1,               //  6815:       decode to VQSUBuv8i8 using decoder 238
                                             //  6815:      }
                                             //  6815:      } // switch Inst[31:24]
                                             //  6815:     }
  1, 23,                                     //  6820:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  6822:      switch Inst[31:24] {
  242, 1, 7,                                 //  6825:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6828:       check predicate 35
  OPC_Decode, 145, 26, 238, 1,               //  6830:       decode to VQSUBsv4i16 using decoder 238
                                             //  6830:      }
  243, 1, 0,                                 //  6835:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6838:       check predicate 35
  OPC_Decode, 153, 26, 238, 1,               //  6840:       decode to VQSUBuv4i16 using decoder 238
                                             //  6840:      }
                                             //  6840:      } // switch Inst[31:24]
                                             //  6840:     }
  2, 23,                                     //  6845:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  6847:      switch Inst[31:24] {
  242, 1, 7,                                 //  6850:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6853:       check predicate 35
  OPC_Decode, 143, 26, 238, 1,               //  6855:       decode to VQSUBsv2i32 using decoder 238
                                             //  6855:      }
  243, 1, 0,                                 //  6860:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6863:       check predicate 35
  OPC_Decode, 151, 26, 238, 1,               //  6865:       decode to VQSUBuv2i32 using decoder 238
                                             //  6865:      }
                                             //  6865:      } // switch Inst[31:24]
                                             //  6865:     }
  3, 0,                                      //  6870:     case 0x3: {
  OPC_SwitchField, 24, 8,                    //  6872:      switch Inst[31:24] {
  242, 1, 7,                                 //  6875:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6878:       check predicate 35
  OPC_Decode, 142, 26, 238, 1,               //  6880:       decode to VQSUBsv1i64 using decoder 238
                                             //  6880:      }
  243, 1, 0,                                 //  6885:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6888:       check predicate 35
  OPC_Decode, 150, 26, 238, 1,               //  6890:       decode to VQSUBuv1i64 using decoder 238
                                             //  6890:      }
                                             //  6890:      } // switch Inst[31:24]
                                             //  6890:     }
                                             //  6890:     } // switch Inst[21:20]
                                             //  6890:    }
  3, 78,                                     //  6895:    case 0x3: {
  OPC_SwitchField, 20, 2,                    //  6897:     switch Inst[21:20] {
  0, 23,                                     //  6900:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  6902:      switch Inst[31:24] {
  242, 1, 7,                                 //  6905:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6908:       check predicate 35
  OPC_Decode, 196, 17, 238, 1,               //  6910:       decode to VCGEsv8i8 using decoder 238
                                             //  6910:      }
  243, 1, 0,                                 //  6915:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6918:       check predicate 35
  OPC_Decode, 202, 17, 238, 1,               //  6920:       decode to VCGEuv8i8 using decoder 238
                                             //  6920:      }
                                             //  6920:      } // switch Inst[31:24]
                                             //  6920:     }
  1, 23,                                     //  6925:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  6927:      switch Inst[31:24] {
  242, 1, 7,                                 //  6930:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6933:       check predicate 35
  OPC_Decode, 193, 17, 238, 1,               //  6935:       decode to VCGEsv4i16 using decoder 238
                                             //  6935:      }
  243, 1, 0,                                 //  6940:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6943:       check predicate 35
  OPC_Decode, 199, 17, 238, 1,               //  6945:       decode to VCGEuv4i16 using decoder 238
                                             //  6945:      }
                                             //  6945:      } // switch Inst[31:24]
                                             //  6945:     }
  2, 0,                                      //  6950:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  6952:      switch Inst[31:24] {
  242, 1, 7,                                 //  6955:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6958:       check predicate 35
  OPC_Decode, 192, 17, 238, 1,               //  6960:       decode to VCGEsv2i32 using decoder 238
                                             //  6960:      }
  243, 1, 0,                                 //  6965:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6968:       check predicate 35
  OPC_Decode, 198, 17, 238, 1,               //  6970:       decode to VCGEuv2i32 using decoder 238
                                             //  6970:      }
                                             //  6970:      } // switch Inst[31:24]
                                             //  6970:     }
                                             //  6970:     } // switch Inst[21:20]
                                             //  6970:    }
  4, 103,                                    //  6975:    case 0x4: {
  OPC_SwitchField, 20, 2,                    //  6977:     switch Inst[21:20] {
  0, 23,                                     //  6980:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  6982:      switch Inst[31:24] {
  242, 1, 7,                                 //  6985:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  6988:       check predicate 35
  OPC_Decode, 243, 25, 242, 1,               //  6990:       decode to VQSHLsv8i8 using decoder 242
                                             //  6990:      }
  243, 1, 0,                                 //  6995:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  6998:       check predicate 35
  OPC_Decode, 131, 26, 242, 1,               //  7000:       decode to VQSHLuv8i8 using decoder 242
                                             //  7000:      }
                                             //  7000:      } // switch Inst[31:24]
                                             //  7000:     }
  1, 23,                                     //  7005:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  7007:      switch Inst[31:24] {
  242, 1, 7,                                 //  7010:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7013:       check predicate 35
  OPC_Decode, 240, 25, 242, 1,               //  7015:       decode to VQSHLsv4i16 using decoder 242
                                             //  7015:      }
  243, 1, 0,                                 //  7020:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7023:       check predicate 35
  OPC_Decode, 128, 26, 242, 1,               //  7025:       decode to VQSHLuv4i16 using decoder 242
                                             //  7025:      }
                                             //  7025:      } // switch Inst[31:24]
                                             //  7025:     }
  2, 23,                                     //  7030:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  7032:      switch Inst[31:24] {
  242, 1, 7,                                 //  7035:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7038:       check predicate 35
  OPC_Decode, 238, 25, 242, 1,               //  7040:       decode to VQSHLsv2i32 using decoder 242
                                             //  7040:      }
  243, 1, 0,                                 //  7045:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7048:       check predicate 35
  OPC_Decode, 254, 25, 242, 1,               //  7050:       decode to VQSHLuv2i32 using decoder 242
                                             //  7050:      }
                                             //  7050:      } // switch Inst[31:24]
                                             //  7050:     }
  3, 0,                                      //  7055:     case 0x3: {
  OPC_SwitchField, 24, 8,                    //  7057:      switch Inst[31:24] {
  242, 1, 7,                                 //  7060:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7063:       check predicate 35
  OPC_Decode, 237, 25, 242, 1,               //  7065:       decode to VQSHLsv1i64 using decoder 242
                                             //  7065:      }
  243, 1, 0,                                 //  7070:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7073:       check predicate 35
  OPC_Decode, 253, 25, 242, 1,               //  7075:       decode to VQSHLuv1i64 using decoder 242
                                             //  7075:      }
                                             //  7075:      } // switch Inst[31:24]
                                             //  7075:     }
                                             //  7075:     } // switch Inst[21:20]
                                             //  7075:    }
  5, 103,                                    //  7080:    case 0x5: {
  OPC_SwitchField, 20, 2,                    //  7082:     switch Inst[21:20] {
  0, 23,                                     //  7085:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  7087:      switch Inst[31:24] {
  242, 1, 7,                                 //  7090:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7093:       check predicate 35
  OPC_Decode, 202, 25, 242, 1,               //  7095:       decode to VQRSHLsv8i8 using decoder 242
                                             //  7095:      }
  243, 1, 0,                                 //  7100:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7103:       check predicate 35
  OPC_Decode, 210, 25, 242, 1,               //  7105:       decode to VQRSHLuv8i8 using decoder 242
                                             //  7105:      }
                                             //  7105:      } // switch Inst[31:24]
                                             //  7105:     }
  1, 23,                                     //  7110:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  7112:      switch Inst[31:24] {
  242, 1, 7,                                 //  7115:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7118:       check predicate 35
  OPC_Decode, 199, 25, 242, 1,               //  7120:       decode to VQRSHLsv4i16 using decoder 242
                                             //  7120:      }
  243, 1, 0,                                 //  7125:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7128:       check predicate 35
  OPC_Decode, 207, 25, 242, 1,               //  7130:       decode to VQRSHLuv4i16 using decoder 242
                                             //  7130:      }
                                             //  7130:      } // switch Inst[31:24]
                                             //  7130:     }
  2, 23,                                     //  7135:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  7137:      switch Inst[31:24] {
  242, 1, 7,                                 //  7140:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7143:       check predicate 35
  OPC_Decode, 197, 25, 242, 1,               //  7145:       decode to VQRSHLsv2i32 using decoder 242
                                             //  7145:      }
  243, 1, 0,                                 //  7150:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7153:       check predicate 35
  OPC_Decode, 205, 25, 242, 1,               //  7155:       decode to VQRSHLuv2i32 using decoder 242
                                             //  7155:      }
                                             //  7155:      } // switch Inst[31:24]
                                             //  7155:     }
  3, 0,                                      //  7160:     case 0x3: {
  OPC_SwitchField, 24, 8,                    //  7162:      switch Inst[31:24] {
  242, 1, 7,                                 //  7165:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7168:       check predicate 35
  OPC_Decode, 196, 25, 242, 1,               //  7170:       decode to VQRSHLsv1i64 using decoder 242
                                             //  7170:      }
  243, 1, 0,                                 //  7175:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7178:       check predicate 35
  OPC_Decode, 204, 25, 242, 1,               //  7180:       decode to VQRSHLuv1i64 using decoder 242
                                             //  7180:      }
                                             //  7180:      } // switch Inst[31:24]
                                             //  7180:     }
                                             //  7180:     } // switch Inst[21:20]
                                             //  7180:    }
  6, 78,                                     //  7185:    case 0x6: {
  OPC_SwitchField, 20, 2,                    //  7187:     switch Inst[21:20] {
  0, 23,                                     //  7190:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  7192:      switch Inst[31:24] {
  242, 1, 7,                                 //  7195:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7198:       check predicate 35
  OPC_Decode, 131, 23, 238, 1,               //  7200:       decode to VMINsv8i8 using decoder 238
                                             //  7200:      }
  243, 1, 0,                                 //  7205:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7208:       check predicate 35
  OPC_Decode, 137, 23, 238, 1,               //  7210:       decode to VMINuv8i8 using decoder 238
                                             //  7210:      }
                                             //  7210:      } // switch Inst[31:24]
                                             //  7210:     }
  1, 23,                                     //  7215:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  7217:      switch Inst[31:24] {
  242, 1, 7,                                 //  7220:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7223:       check predicate 35
  OPC_Decode, 128, 23, 238, 1,               //  7225:       decode to VMINsv4i16 using decoder 238
                                             //  7225:      }
  243, 1, 0,                                 //  7230:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7233:       check predicate 35
  OPC_Decode, 134, 23, 238, 1,               //  7235:       decode to VMINuv4i16 using decoder 238
                                             //  7235:      }
                                             //  7235:      } // switch Inst[31:24]
                                             //  7235:     }
  2, 0,                                      //  7240:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  7242:      switch Inst[31:24] {
  242, 1, 7,                                 //  7245:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7248:       check predicate 35
  OPC_Decode, 255, 22, 238, 1,               //  7250:       decode to VMINsv2i32 using decoder 238
                                             //  7250:      }
  243, 1, 0,                                 //  7255:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7258:       check predicate 35
  OPC_Decode, 133, 23, 238, 1,               //  7260:       decode to VMINuv2i32 using decoder 238
                                             //  7260:      }
                                             //  7260:      } // switch Inst[31:24]
                                             //  7260:     }
                                             //  7260:     } // switch Inst[21:20]
                                             //  7260:    }
  7, 78,                                     //  7265:    case 0x7: {
  OPC_SwitchField, 20, 2,                    //  7267:     switch Inst[21:20] {
  0, 23,                                     //  7270:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  7272:      switch Inst[31:24] {
  242, 1, 7,                                 //  7275:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7278:       check predicate 35
  OPC_Decode, 191, 16, 246, 1,               //  7280:       decode to VABAsv8i8 using decoder 246
                                             //  7280:      }
  243, 1, 0,                                 //  7285:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7288:       check predicate 35
  OPC_Decode, 197, 16, 246, 1,               //  7290:       decode to VABAuv8i8 using decoder 246
                                             //  7290:      }
                                             //  7290:      } // switch Inst[31:24]
                                             //  7290:     }
  1, 23,                                     //  7295:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  7297:      switch Inst[31:24] {
  242, 1, 7,                                 //  7300:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7303:       check predicate 35
  OPC_Decode, 188, 16, 246, 1,               //  7305:       decode to VABAsv4i16 using decoder 246
                                             //  7305:      }
  243, 1, 0,                                 //  7310:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7313:       check predicate 35
  OPC_Decode, 194, 16, 246, 1,               //  7315:       decode to VABAuv4i16 using decoder 246
                                             //  7315:      }
                                             //  7315:      } // switch Inst[31:24]
                                             //  7315:     }
  2, 0,                                      //  7320:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  7322:      switch Inst[31:24] {
  242, 1, 7,                                 //  7325:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7328:       check predicate 35
  OPC_Decode, 187, 16, 246, 1,               //  7330:       decode to VABAsv2i32 using decoder 246
                                             //  7330:      }
  243, 1, 0,                                 //  7335:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7338:       check predicate 35
  OPC_Decode, 193, 16, 246, 1,               //  7340:       decode to VABAuv2i32 using decoder 246
                                             //  7340:      }
                                             //  7340:      } // switch Inst[31:24]
                                             //  7340:     }
                                             //  7340:     } // switch Inst[21:20]
                                             //  7340:    }
  8, 78,                                     //  7345:    case 0x8: {
  OPC_SwitchField, 20, 2,                    //  7347:     switch Inst[21:20] {
  0, 23,                                     //  7350:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  7352:      switch Inst[31:24] {
  242, 1, 7,                                 //  7355:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7358:       check predicate 35
  OPC_Decode, 148, 31, 238, 1,               //  7360:       decode to VTSTv8i8 using decoder 238
                                             //  7360:      }
  243, 1, 0,                                 //  7365:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7368:       check predicate 35
  OPC_Decode, 176, 17, 238, 1,               //  7370:       decode to VCEQv8i8 using decoder 238
                                             //  7370:      }
                                             //  7370:      } // switch Inst[31:24]
                                             //  7370:     }
  1, 23,                                     //  7375:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  7377:      switch Inst[31:24] {
  242, 1, 7,                                 //  7380:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7383:       check predicate 35
  OPC_Decode, 145, 31, 238, 1,               //  7385:       decode to VTSTv4i16 using decoder 238
                                             //  7385:      }
  243, 1, 0,                                 //  7390:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7393:       check predicate 35
  OPC_Decode, 173, 17, 238, 1,               //  7395:       decode to VCEQv4i16 using decoder 238
                                             //  7395:      }
                                             //  7395:      } // switch Inst[31:24]
                                             //  7395:     }
  2, 0,                                      //  7400:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  7402:      switch Inst[31:24] {
  242, 1, 7,                                 //  7405:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7408:       check predicate 35
  OPC_Decode, 144, 31, 238, 1,               //  7410:       decode to VTSTv2i32 using decoder 238
                                             //  7410:      }
  243, 1, 0,                                 //  7415:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7418:       check predicate 35
  OPC_Decode, 172, 17, 238, 1,               //  7420:       decode to VCEQv2i32 using decoder 238
                                             //  7420:      }
                                             //  7420:      } // switch Inst[31:24]
                                             //  7420:     }
                                             //  7420:     } // switch Inst[21:20]
                                             //  7420:    }
  9, 56,                                     //  7425:    case 0x9: {
  OPC_SwitchField, 20, 2,                    //  7427:     switch Inst[21:20] {
  0, 23,                                     //  7430:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  7432:      switch Inst[31:24] {
  242, 1, 7,                                 //  7435:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7438:       check predicate 35
  OPC_Decode, 160, 24, 238, 1,               //  7440:       decode to VMULv8i8 using decoder 238
                                             //  7440:      }
  243, 1, 0,                                 //  7445:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7448:       check predicate 35
  OPC_Decode, 145, 24, 238, 1,               //  7450:       decode to VMULpd using decoder 238
                                             //  7450:      }
                                             //  7450:      } // switch Inst[31:24]
                                             //  7450:     }
  1, 12,                                     //  7455:     case 0x1: {
  OPC_CheckPredicate, 35,                    //  7457:      check predicate 35
  OPC_CheckField, 24, 8, 242, 1,             //  7459:      check Inst[31:24] == 0xf2
  OPC_Decode, 157, 24, 238, 1,               //  7464:      decode to VMULv4i16 using decoder 238
                                             //  7464:     }
  2, 0,                                      //  7469:     case 0x2: {
  OPC_CheckPredicate, 35,                    //  7471:      check predicate 35
  OPC_CheckField, 24, 8, 242, 1,             //  7473:      check Inst[31:24] == 0xf2
  OPC_Decode, 156, 24, 238, 1,               //  7478:      decode to VMULv2i32 using decoder 238
                                             //  7478:     }
                                             //  7478:     } // switch Inst[21:20]
                                             //  7478:    }
  10, 78,                                    //  7483:    case 0xa: {
  OPC_SwitchField, 20, 2,                    //  7485:     switch Inst[21:20] {
  0, 23,                                     //  7488:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  7490:      switch Inst[31:24] {
  242, 1, 7,                                 //  7493:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7496:       check predicate 35
  OPC_Decode, 238, 24, 238, 1,               //  7498:       decode to VPMINs8 using decoder 238
                                             //  7498:      }
  243, 1, 0,                                 //  7503:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7506:       check predicate 35
  OPC_Decode, 241, 24, 238, 1,               //  7508:       decode to VPMINu8 using decoder 238
                                             //  7508:      }
                                             //  7508:      } // switch Inst[31:24]
                                             //  7508:     }
  1, 23,                                     //  7513:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  7515:      switch Inst[31:24] {
  242, 1, 7,                                 //  7518:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7521:       check predicate 35
  OPC_Decode, 236, 24, 238, 1,               //  7523:       decode to VPMINs16 using decoder 238
                                             //  7523:      }
  243, 1, 0,                                 //  7528:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7531:       check predicate 35
  OPC_Decode, 239, 24, 238, 1,               //  7533:       decode to VPMINu16 using decoder 238
                                             //  7533:      }
                                             //  7533:      } // switch Inst[31:24]
                                             //  7533:     }
  2, 0,                                      //  7538:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  7540:      switch Inst[31:24] {
  242, 1, 7,                                 //  7543:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7546:       check predicate 35
  OPC_Decode, 237, 24, 238, 1,               //  7548:       decode to VPMINs32 using decoder 238
                                             //  7548:      }
  243, 1, 0,                                 //  7553:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7556:       check predicate 35
  OPC_Decode, 240, 24, 238, 1,               //  7558:       decode to VPMINu32 using decoder 238
                                             //  7558:      }
                                             //  7558:      } // switch Inst[31:24]
                                             //  7558:     }
                                             //  7558:     } // switch Inst[21:20]
                                             //  7558:    }
  11, 67,                                    //  7563:    case 0xb: {
  OPC_SwitchField, 20, 2,                    //  7565:     switch Inst[21:20] {
  0, 12,                                     //  7568:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  7570:      check predicate 35
  OPC_CheckField, 24, 8, 242, 1,             //  7572:      check Inst[31:24] == 0xf2
  OPC_Decode, 225, 24, 238, 1,               //  7577:      decode to VPADDi8 using decoder 238
                                             //  7577:     }
  1, 23,                                     //  7582:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  7584:      switch Inst[31:24] {
  242, 1, 7,                                 //  7587:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7590:       check predicate 35
  OPC_Decode, 223, 24, 238, 1,               //  7592:       decode to VPADDi16 using decoder 238
                                             //  7592:      }
  243, 1, 0,                                 //  7597:      case 0xf3: {
  OPC_CheckPredicate, 37,                    //  7600:       check predicate 37
  OPC_Decode, 176, 25, 246, 1,               //  7602:       decode to VQRDMLAHv4i16 using decoder 246
                                             //  7602:      }
                                             //  7602:      } // switch Inst[31:24]
                                             //  7602:     }
  2, 0,                                      //  7607:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  7609:      switch Inst[31:24] {
  242, 1, 7,                                 //  7612:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7615:       check predicate 35
  OPC_Decode, 224, 24, 238, 1,               //  7617:       decode to VPADDi32 using decoder 238
                                             //  7617:      }
  243, 1, 0,                                 //  7622:      case 0xf3: {
  OPC_CheckPredicate, 37,                    //  7625:       check predicate 37
  OPC_Decode, 175, 25, 246, 1,               //  7627:       decode to VQRDMLAHv2i32 using decoder 246
                                             //  7627:      }
                                             //  7627:      } // switch Inst[31:24]
                                             //  7627:     }
                                             //  7627:     } // switch Inst[21:20]
                                             //  7627:    }
  12, 81,                                    //  7632:    case 0xc: {
  OPC_SwitchField, 20, 2,                    //  7634:     switch Inst[21:20] {
  0, 12,                                     //  7637:     case 0x0: {
  OPC_CheckPredicate, 41,                    //  7639:      check predicate 41
  OPC_CheckField, 24, 8, 242, 1,             //  7641:      check Inst[31:24] == 0xf2
  OPC_Decode, 168, 19, 246, 1,               //  7646:      decode to VFMAfd using decoder 246
                                             //  7646:     }
  1, 23,                                     //  7651:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  7653:      switch Inst[31:24] {
  242, 1, 7,                                 //  7656:      case 0xf2: {
  OPC_CheckPredicate, 36,                    //  7659:       check predicate 36
  OPC_Decode, 170, 19, 246, 1,               //  7661:       decode to VFMAhd using decoder 246
                                             //  7661:      }
  243, 1, 0,                                 //  7666:      case 0xf3: {
  OPC_CheckPredicate, 37,                    //  7669:       check predicate 37
  OPC_Decode, 184, 25, 246, 1,               //  7671:       decode to VQRDMLSHv4i16 using decoder 246
                                             //  7671:      }
                                             //  7671:      } // switch Inst[31:24]
                                             //  7671:     }
  2, 23,                                     //  7676:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  7678:      switch Inst[31:24] {
  242, 1, 7,                                 //  7681:      case 0xf2: {
  OPC_CheckPredicate, 41,                    //  7684:       check predicate 41
  OPC_Decode, 179, 19, 246, 1,               //  7686:       decode to VFMSfd using decoder 246
                                             //  7686:      }
  243, 1, 0,                                 //  7691:      case 0xf3: {
  OPC_CheckPredicate, 37,                    //  7694:       check predicate 37
  OPC_Decode, 183, 25, 246, 1,               //  7696:       decode to VQRDMLSHv2i32 using decoder 246
                                             //  7696:      }
                                             //  7696:      } // switch Inst[31:24]
                                             //  7696:     }
  3, 0,                                      //  7701:     case 0x3: {
  OPC_CheckPredicate, 36,                    //  7703:      check predicate 36
  OPC_CheckField, 24, 8, 242, 1,             //  7705:      check Inst[31:24] == 0xf2
  OPC_Decode, 181, 19, 246, 1,               //  7710:      decode to VFMShd using decoder 246
                                             //  7710:     }
                                             //  7710:     } // switch Inst[21:20]
                                             //  7710:    }
  13, 81,                                    //  7715:    case 0xd: {
  OPC_SwitchField, 20, 2,                    //  7717:     switch Inst[21:20] {
  0, 23,                                     //  7720:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  7722:      switch Inst[31:24] {
  242, 1, 7,                                 //  7725:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  7728:       check predicate 35
  OPC_Decode, 151, 23, 246, 1,               //  7730:       decode to VMLAfd using decoder 246
                                             //  7730:      }
  243, 1, 0,                                 //  7735:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  7738:       check predicate 35
  OPC_Decode, 141, 24, 238, 1,               //  7740:       decode to VMULfd using decoder 238
                                             //  7740:      }
                                             //  7740:      } // switch Inst[31:24]
                                             //  7740:     }
  1, 23,                                     //  7745:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  7747:      switch Inst[31:24] {
  242, 1, 7,                                 //  7750:      case 0xf2: {
  OPC_CheckPredicate, 36,                    //  7753:       check predicate 36
  OPC_Decode, 153, 23, 246, 1,               //  7755:       decode to VMLAhd using decoder 246
                                             //  7755:      }
  243, 1, 0,                                 //  7760:      case 0xf3: {
  OPC_CheckPredicate, 36,                    //  7763:       check predicate 36
  OPC_Decode, 143, 24, 238, 1,               //  7765:       decode to VMULhd using decoder 238
                                             //  7765:      }
                                             //  7765:      } // switch Inst[31:24]
                                             //  7765:     }
  2, 12,                                     //  7770:     case 0x2: {
  OPC_CheckPredicate, 35,                    //  7772:      check predicate 35
  OPC_CheckField, 24, 8, 242, 1,             //  7774:      check Inst[31:24] == 0xf2
  OPC_Decode, 182, 23, 246, 1,               //  7779:      decode to VMLSfd using decoder 246
                                             //  7779:     }
  3, 0,                                      //  7784:     case 0x3: {
  OPC_CheckPredicate, 36,                    //  7786:      check predicate 36
  OPC_CheckField, 24, 8, 242, 1,             //  7788:      check Inst[31:24] == 0xf2
  OPC_Decode, 184, 23, 246, 1,               //  7793:      decode to VMLShd using decoder 246
                                             //  7793:     }
                                             //  7793:     } // switch Inst[21:20]
                                             //  7793:    }
  14, 59,                                    //  7798:    case 0xe: {
  OPC_SwitchField, 20, 2,                    //  7800:     switch Inst[21:20] {
  0, 12,                                     //  7803:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  7805:      check predicate 35
  OPC_CheckField, 24, 8, 243, 1,             //  7807:      check Inst[31:24] == 0xf3
  OPC_Decode, 233, 16, 238, 1,               //  7812:      decode to VACGEfd using decoder 238
                                             //  7812:     }
  1, 12,                                     //  7817:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  7819:      check predicate 36
  OPC_CheckField, 24, 8, 243, 1,             //  7821:      check Inst[31:24] == 0xf3
  OPC_Decode, 235, 16, 238, 1,               //  7826:      decode to VACGEhd using decoder 238
                                             //  7826:     }
  2, 12,                                     //  7831:     case 0x2: {
  OPC_CheckPredicate, 35,                    //  7833:      check predicate 35
  OPC_CheckField, 24, 8, 243, 1,             //  7835:      check Inst[31:24] == 0xf3
  OPC_Decode, 237, 16, 238, 1,               //  7840:      decode to VACGTfd using decoder 238
                                             //  7840:     }
  3, 0,                                      //  7845:     case 0x3: {
  OPC_CheckPredicate, 36,                    //  7847:      check predicate 36
  OPC_CheckField, 24, 8, 243, 1,             //  7849:      check Inst[31:24] == 0xf3
  OPC_Decode, 239, 16, 238, 1,               //  7854:      decode to VACGThd using decoder 238
                                             //  7854:     }
                                             //  7854:     } // switch Inst[21:20]
                                             //  7854:    }
  15, 0,                                     //  7859:    case 0xf: {
  OPC_SwitchField, 20, 2,                    //  7861:     switch Inst[21:20] {
  0, 12,                                     //  7864:     case 0x0: {
  OPC_CheckPredicate, 35,                    //  7866:      check predicate 35
  OPC_CheckField, 24, 8, 242, 1,             //  7868:      check Inst[31:24] == 0xf2
  OPC_Decode, 166, 26, 238, 1,               //  7873:      decode to VRECPSfd using decoder 238
                                             //  7873:     }
  1, 12,                                     //  7878:     case 0x1: {
  OPC_CheckPredicate, 36,                    //  7880:      check predicate 36
  OPC_CheckField, 24, 8, 242, 1,             //  7882:      check Inst[31:24] == 0xf2
  OPC_Decode, 168, 26, 238, 1,               //  7887:      decode to VRECPShd using decoder 238
                                             //  7887:     }
  2, 12,                                     //  7892:     case 0x2: {
  OPC_CheckPredicate, 35,                    //  7894:      check predicate 35
  OPC_CheckField, 24, 8, 242, 1,             //  7896:      check Inst[31:24] == 0xf2
  OPC_Decode, 152, 27, 238, 1,               //  7901:      decode to VRSQRTSfd using decoder 238
                                             //  7901:     }
  3, 0,                                      //  7906:     case 0x3: {
  OPC_CheckPredicate, 36,                    //  7908:      check predicate 36
  OPC_CheckField, 24, 8, 242, 1,             //  7910:      check Inst[31:24] == 0xf2
  OPC_Decode, 154, 27, 238, 1,               //  7915:      decode to VRSQRTShd using decoder 238
                                             //  7915:     }
                                             //  7915:     } // switch Inst[21:20]
                                             //  7915:    }
                                             //  7915:    } // switch Inst[11:8]
                                             //  7915:   }
  1, 0,                                      //  7920:   case 0x1: {
  OPC_SwitchField, 7, 1,                     //  7922:    switch Inst[7] {
  0, 213, 9,                                 //  7925:    case 0x0: {
  OPC_CheckField, 25, 7, 121,                //  7928:     check Inst[31:25] == 0x79
  OPC_Scope, 215, 8,                         //  7932:     try {
  OPC_SwitchField, 8, 4,                     //  7935:      switch Inst[11:8] {
  0, 85,                                     //  7938:      case 0x0: {
  OPC_SwitchField, 21, 1,                    //  7940:       switch Inst[21] {
  0, 57,                                     //  7943:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  7945:        switch Inst[20] {
  0, 29,                                     //  7948:        case 0x0: {
  OPC_SwitchField, 24, 1,                    //  7950:         switch Inst[24] {
  0, 11,                                     //  7953:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  7955:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  7957:          check Inst[19] == 0x1
  OPC_Decode, 239, 27, 156, 2,               //  7961:          decode to VSHRsv8i8 using decoder 284
                                             //  7961:         }
  1, 0,                                      //  7966:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  7968:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  7970:          check Inst[19] == 0x1
  OPC_Decode, 247, 27, 156, 2,               //  7974:          decode to VSHRuv8i8 using decoder 284
                                             //  7974:         }
                                             //  7974:         } // switch Inst[24]
                                             //  7974:        }
  1, 0,                                      //  7979:        case 0x1: {
  OPC_SwitchField, 24, 1,                    //  7981:         switch Inst[24] {
  0, 7,                                      //  7984:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  7986:          check predicate 35
  OPC_Decode, 236, 27, 157, 2,               //  7988:          decode to VSHRsv4i16 using decoder 285
                                             //  7988:         }
  1, 0,                                      //  7993:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  7995:          check predicate 35
  OPC_Decode, 244, 27, 157, 2,               //  7997:          decode to VSHRuv4i16 using decoder 285
                                             //  7997:         }
                                             //  7997:         } // switch Inst[24]
                                             //  7997:        }
                                             //  7997:        } // switch Inst[20]
                                             //  7997:       }
  1, 0,                                      //  8002:       case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8004:        switch Inst[24] {
  0, 7,                                      //  8007:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8009:         check predicate 35
  OPC_Decode, 234, 27, 158, 2,               //  8011:         decode to VSHRsv2i32 using decoder 286
                                             //  8011:        }
  1, 0,                                      //  8016:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8018:         check predicate 35
  OPC_Decode, 242, 27, 158, 2,               //  8020:         decode to VSHRuv2i32 using decoder 286
                                             //  8020:        }
                                             //  8020:        } // switch Inst[24]
                                             //  8020:       }
                                             //  8020:       } // switch Inst[21]
                                             //  8020:      }
  1, 85,                                     //  8025:      case 0x1: {
  OPC_SwitchField, 21, 1,                    //  8027:       switch Inst[21] {
  0, 57,                                     //  8030:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  8032:        switch Inst[20] {
  0, 29,                                     //  8035:        case 0x0: {
  OPC_SwitchField, 24, 1,                    //  8037:         switch Inst[24] {
  0, 11,                                     //  8040:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8042:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8044:          check Inst[19] == 0x1
  OPC_Decode, 148, 28, 159, 2,               //  8048:          decode to VSRAsv8i8 using decoder 287
                                             //  8048:         }
  1, 0,                                      //  8053:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8055:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8057:          check Inst[19] == 0x1
  OPC_Decode, 156, 28, 159, 2,               //  8061:          decode to VSRAuv8i8 using decoder 287
                                             //  8061:         }
                                             //  8061:         } // switch Inst[24]
                                             //  8061:        }
  1, 0,                                      //  8066:        case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8068:         switch Inst[24] {
  0, 7,                                      //  8071:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8073:          check predicate 35
  OPC_Decode, 145, 28, 160, 2,               //  8075:          decode to VSRAsv4i16 using decoder 288
                                             //  8075:         }
  1, 0,                                      //  8080:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8082:          check predicate 35
  OPC_Decode, 153, 28, 160, 2,               //  8084:          decode to VSRAuv4i16 using decoder 288
                                             //  8084:         }
                                             //  8084:         } // switch Inst[24]
                                             //  8084:        }
                                             //  8084:        } // switch Inst[20]
                                             //  8084:       }
  1, 0,                                      //  8089:       case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8091:        switch Inst[24] {
  0, 7,                                      //  8094:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8096:         check predicate 35
  OPC_Decode, 143, 28, 161, 2,               //  8098:         decode to VSRAsv2i32 using decoder 289
                                             //  8098:        }
  1, 0,                                      //  8103:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8105:         check predicate 35
  OPC_Decode, 151, 28, 161, 2,               //  8107:         decode to VSRAuv2i32 using decoder 289
                                             //  8107:        }
                                             //  8107:        } // switch Inst[24]
                                             //  8107:       }
                                             //  8107:       } // switch Inst[21]
                                             //  8107:      }
  2, 85,                                     //  8112:      case 0x2: {
  OPC_SwitchField, 21, 1,                    //  8114:       switch Inst[21] {
  0, 57,                                     //  8117:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  8119:        switch Inst[20] {
  0, 29,                                     //  8122:        case 0x0: {
  OPC_SwitchField, 24, 1,                    //  8124:         switch Inst[24] {
  0, 11,                                     //  8127:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8129:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8131:          check Inst[19] == 0x1
  OPC_Decode, 137, 27, 156, 2,               //  8135:          decode to VRSHRsv8i8 using decoder 284
                                             //  8135:         }
  1, 0,                                      //  8140:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8142:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8144:          check Inst[19] == 0x1
  OPC_Decode, 145, 27, 156, 2,               //  8148:          decode to VRSHRuv8i8 using decoder 284
                                             //  8148:         }
                                             //  8148:         } // switch Inst[24]
                                             //  8148:        }
  1, 0,                                      //  8153:        case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8155:         switch Inst[24] {
  0, 7,                                      //  8158:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8160:          check predicate 35
  OPC_Decode, 134, 27, 157, 2,               //  8162:          decode to VRSHRsv4i16 using decoder 285
                                             //  8162:         }
  1, 0,                                      //  8167:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8169:          check predicate 35
  OPC_Decode, 142, 27, 157, 2,               //  8171:          decode to VRSHRuv4i16 using decoder 285
                                             //  8171:         }
                                             //  8171:         } // switch Inst[24]
                                             //  8171:        }
                                             //  8171:        } // switch Inst[20]
                                             //  8171:       }
  1, 0,                                      //  8176:       case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8178:        switch Inst[24] {
  0, 7,                                      //  8181:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8183:         check predicate 35
  OPC_Decode, 132, 27, 158, 2,               //  8185:         decode to VRSHRsv2i32 using decoder 286
                                             //  8185:        }
  1, 0,                                      //  8190:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8192:         check predicate 35
  OPC_Decode, 140, 27, 158, 2,               //  8194:         decode to VRSHRuv2i32 using decoder 286
                                             //  8194:        }
                                             //  8194:        } // switch Inst[24]
                                             //  8194:       }
                                             //  8194:       } // switch Inst[21]
                                             //  8194:      }
  3, 85,                                     //  8199:      case 0x3: {
  OPC_SwitchField, 21, 1,                    //  8201:       switch Inst[21] {
  0, 57,                                     //  8204:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  8206:        switch Inst[20] {
  0, 29,                                     //  8209:        case 0x0: {
  OPC_SwitchField, 24, 1,                    //  8211:         switch Inst[24] {
  0, 11,                                     //  8214:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8216:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8218:          check Inst[19] == 0x1
  OPC_Decode, 163, 27, 159, 2,               //  8222:          decode to VRSRAsv8i8 using decoder 287
                                             //  8222:         }
  1, 0,                                      //  8227:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8229:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8231:          check Inst[19] == 0x1
  OPC_Decode, 171, 27, 159, 2,               //  8235:          decode to VRSRAuv8i8 using decoder 287
                                             //  8235:         }
                                             //  8235:         } // switch Inst[24]
                                             //  8235:        }
  1, 0,                                      //  8240:        case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8242:         switch Inst[24] {
  0, 7,                                      //  8245:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8247:          check predicate 35
  OPC_Decode, 160, 27, 160, 2,               //  8249:          decode to VRSRAsv4i16 using decoder 288
                                             //  8249:         }
  1, 0,                                      //  8254:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8256:          check predicate 35
  OPC_Decode, 168, 27, 160, 2,               //  8258:          decode to VRSRAuv4i16 using decoder 288
                                             //  8258:         }
                                             //  8258:         } // switch Inst[24]
                                             //  8258:        }
                                             //  8258:        } // switch Inst[20]
                                             //  8258:       }
  1, 0,                                      //  8263:       case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8265:        switch Inst[24] {
  0, 7,                                      //  8268:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8270:         check predicate 35
  OPC_Decode, 158, 27, 161, 2,               //  8272:         decode to VRSRAsv2i32 using decoder 289
                                             //  8272:        }
  1, 0,                                      //  8277:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8279:         check predicate 35
  OPC_Decode, 166, 27, 161, 2,               //  8281:         decode to VRSRAuv2i32 using decoder 289
                                             //  8281:        }
                                             //  8281:        } // switch Inst[24]
                                             //  8281:       }
                                             //  8281:       } // switch Inst[21]
                                             //  8281:      }
  4, 51,                                     //  8286:      case 0x4: {
  OPC_SwitchField, 21, 1,                    //  8288:       switch Inst[21] {
  0, 33,                                     //  8291:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  8293:        switch Inst[20] {
  0, 15,                                     //  8296:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8298:         check predicate 35
  OPC_CheckField, 24, 1, 1,                  //  8300:         check Inst[24] == 0x1
  OPC_CheckField, 19, 1, 1,                  //  8304:         check Inst[19] == 0x1
  OPC_Decode, 164, 28, 159, 2,               //  8308:         decode to VSRIv8i8 using decoder 287
                                             //  8308:        }
  1, 0,                                      //  8313:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8315:         check predicate 35
  OPC_CheckField, 24, 1, 1,                  //  8317:         check Inst[24] == 0x1
  OPC_Decode, 161, 28, 160, 2,               //  8321:         decode to VSRIv4i16 using decoder 288
                                             //  8321:        }
                                             //  8321:        } // switch Inst[20]
                                             //  8321:       }
  1, 0,                                      //  8326:       case 0x1: {
  OPC_CheckPredicate, 35,                    //  8328:        check predicate 35
  OPC_CheckField, 24, 1, 1,                  //  8330:        check Inst[24] == 0x1
  OPC_Decode, 159, 28, 161, 2,               //  8334:        decode to VSRIv2i32 using decoder 289
                                             //  8334:       }
                                             //  8334:       } // switch Inst[21]
                                             //  8334:      }
  5, 85,                                     //  8339:      case 0x5: {
  OPC_SwitchField, 21, 1,                    //  8341:       switch Inst[21] {
  0, 57,                                     //  8344:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  8346:        switch Inst[20] {
  0, 29,                                     //  8349:        case 0x0: {
  OPC_SwitchField, 24, 1,                    //  8351:         switch Inst[24] {
  0, 11,                                     //  8354:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8356:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8358:          check Inst[19] == 0x1
  OPC_Decode, 212, 27, 162, 2,               //  8362:          decode to VSHLiv8i8 using decoder 290
                                             //  8362:         }
  1, 0,                                      //  8367:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8369:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8371:          check Inst[19] == 0x1
  OPC_Decode, 133, 28, 163, 2,               //  8375:          decode to VSLIv8i8 using decoder 291
                                             //  8375:         }
                                             //  8375:         } // switch Inst[24]
                                             //  8375:        }
  1, 0,                                      //  8380:        case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8382:         switch Inst[24] {
  0, 7,                                      //  8385:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8387:          check predicate 35
  OPC_Decode, 209, 27, 164, 2,               //  8389:          decode to VSHLiv4i16 using decoder 292
                                             //  8389:         }
  1, 0,                                      //  8394:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8396:          check predicate 35
  OPC_Decode, 130, 28, 165, 2,               //  8398:          decode to VSLIv4i16 using decoder 293
                                             //  8398:         }
                                             //  8398:         } // switch Inst[24]
                                             //  8398:        }
                                             //  8398:        } // switch Inst[20]
                                             //  8398:       }
  1, 0,                                      //  8403:       case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8405:        switch Inst[24] {
  0, 7,                                      //  8408:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8410:         check predicate 35
  OPC_Decode, 207, 27, 166, 2,               //  8412:         decode to VSHLiv2i32 using decoder 294
                                             //  8412:        }
  1, 0,                                      //  8417:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8419:         check predicate 35
  OPC_Decode, 128, 28, 167, 2,               //  8421:         decode to VSLIv2i32 using decoder 295
                                             //  8421:        }
                                             //  8421:        } // switch Inst[24]
                                             //  8421:       }
                                             //  8421:       } // switch Inst[21]
                                             //  8421:      }
  6, 51,                                     //  8426:      case 0x6: {
  OPC_SwitchField, 21, 1,                    //  8428:       switch Inst[21] {
  0, 33,                                     //  8431:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  8433:        switch Inst[20] {
  0, 15,                                     //  8436:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8438:         check predicate 35
  OPC_CheckField, 24, 1, 1,                  //  8440:         check Inst[24] == 0x1
  OPC_CheckField, 19, 1, 1,                  //  8444:         check Inst[19] == 0x1
  OPC_Decode, 235, 25, 162, 2,               //  8448:         decode to VQSHLsuv8i8 using decoder 290
                                             //  8448:        }
  1, 0,                                      //  8453:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8455:         check predicate 35
  OPC_CheckField, 24, 1, 1,                  //  8457:         check Inst[24] == 0x1
  OPC_Decode, 232, 25, 164, 2,               //  8461:         decode to VQSHLsuv4i16 using decoder 292
                                             //  8461:        }
                                             //  8461:        } // switch Inst[20]
                                             //  8461:       }
  1, 0,                                      //  8466:       case 0x1: {
  OPC_CheckPredicate, 35,                    //  8468:        check predicate 35
  OPC_CheckField, 24, 1, 1,                  //  8470:        check Inst[24] == 0x1
  OPC_Decode, 230, 25, 166, 2,               //  8474:        decode to VQSHLsuv2i32 using decoder 294
                                             //  8474:       }
                                             //  8474:       } // switch Inst[21]
                                             //  8474:      }
  7, 85,                                     //  8479:      case 0x7: {
  OPC_SwitchField, 21, 1,                    //  8481:       switch Inst[21] {
  0, 57,                                     //  8484:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  8486:        switch Inst[20] {
  0, 29,                                     //  8489:        case 0x0: {
  OPC_SwitchField, 24, 1,                    //  8491:         switch Inst[24] {
  0, 11,                                     //  8494:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8496:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8498:          check Inst[19] == 0x1
  OPC_Decode, 227, 25, 162, 2,               //  8502:          decode to VQSHLsiv8i8 using decoder 290
                                             //  8502:         }
  1, 0,                                      //  8507:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8509:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8511:          check Inst[19] == 0x1
  OPC_Decode, 251, 25, 162, 2,               //  8515:          decode to VQSHLuiv8i8 using decoder 290
                                             //  8515:         }
                                             //  8515:         } // switch Inst[24]
                                             //  8515:        }
  1, 0,                                      //  8520:        case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8522:         switch Inst[24] {
  0, 7,                                      //  8525:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8527:          check predicate 35
  OPC_Decode, 224, 25, 164, 2,               //  8529:          decode to VQSHLsiv4i16 using decoder 292
                                             //  8529:         }
  1, 0,                                      //  8534:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8536:          check predicate 35
  OPC_Decode, 248, 25, 164, 2,               //  8538:          decode to VQSHLuiv4i16 using decoder 292
                                             //  8538:         }
                                             //  8538:         } // switch Inst[24]
                                             //  8538:        }
                                             //  8538:        } // switch Inst[20]
                                             //  8538:       }
  1, 0,                                      //  8543:       case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8545:        switch Inst[24] {
  0, 7,                                      //  8548:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8550:         check predicate 35
  OPC_Decode, 222, 25, 166, 2,               //  8552:         decode to VQSHLsiv2i32 using decoder 294
                                             //  8552:        }
  1, 0,                                      //  8557:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8559:         check predicate 35
  OPC_Decode, 246, 25, 166, 2,               //  8561:         decode to VQSHLuiv2i32 using decoder 294
                                             //  8561:        }
                                             //  8561:        } // switch Inst[24]
                                             //  8561:       }
                                             //  8561:       } // switch Inst[21]
                                             //  8561:      }
  8, 85,                                     //  8566:      case 0x8: {
  OPC_SwitchField, 21, 1,                    //  8568:       switch Inst[21] {
  0, 57,                                     //  8571:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  8573:        switch Inst[20] {
  0, 29,                                     //  8576:        case 0x0: {
  OPC_SwitchField, 24, 1,                    //  8578:         switch Inst[24] {
  0, 11,                                     //  8581:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8583:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8585:          check Inst[19] == 0x1
  OPC_Decode, 231, 27, 168, 2,               //  8589:          decode to VSHRNv8i8 using decoder 296
                                             //  8589:         }
  1, 0,                                      //  8594:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8596:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8598:          check Inst[19] == 0x1
  OPC_Decode, 140, 26, 168, 2,               //  8602:          decode to VQSHRUNv8i8 using decoder 296
                                             //  8602:         }
                                             //  8602:         } // switch Inst[24]
                                             //  8602:        }
  1, 0,                                      //  8607:        case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8609:         switch Inst[24] {
  0, 7,                                      //  8612:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8614:          check predicate 35
  OPC_Decode, 230, 27, 169, 2,               //  8616:          decode to VSHRNv4i16 using decoder 297
                                             //  8616:         }
  1, 0,                                      //  8621:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8623:          check predicate 35
  OPC_Decode, 139, 26, 169, 2,               //  8625:          decode to VQSHRUNv4i16 using decoder 297
                                             //  8625:         }
                                             //  8625:         } // switch Inst[24]
                                             //  8625:        }
                                             //  8625:        } // switch Inst[20]
                                             //  8625:       }
  1, 0,                                      //  8630:       case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8632:        switch Inst[24] {
  0, 7,                                      //  8635:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8637:         check predicate 35
  OPC_Decode, 229, 27, 170, 2,               //  8639:         decode to VSHRNv2i32 using decoder 298
                                             //  8639:        }
  1, 0,                                      //  8644:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8646:         check predicate 35
  OPC_Decode, 138, 26, 170, 2,               //  8648:         decode to VQSHRUNv2i32 using decoder 298
                                             //  8648:        }
                                             //  8648:        } // switch Inst[24]
                                             //  8648:       }
                                             //  8648:       } // switch Inst[21]
                                             //  8648:      }
  9, 85,                                     //  8653:      case 0x9: {
  OPC_SwitchField, 21, 1,                    //  8655:       switch Inst[21] {
  0, 57,                                     //  8658:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  8660:        switch Inst[20] {
  0, 29,                                     //  8663:        case 0x0: {
  OPC_SwitchField, 24, 1,                    //  8665:         switch Inst[24] {
  0, 11,                                     //  8668:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8670:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8672:          check Inst[19] == 0x1
  OPC_Decode, 134, 26, 168, 2,               //  8676:          decode to VQSHRNsv8i8 using decoder 296
                                             //  8676:         }
  1, 0,                                      //  8681:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8683:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  //  8685:          check Inst[19] == 0x1
  OPC_Decode, 137, 26, 168, 2,               //  8689:          decode to VQSHRNuv8i8 using decoder 296
                                             //  8689:         }
                                             //  8689:         } // switch Inst[24]
                                             //  8689:        }
  1, 0,                                      //  8694:        case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8696:         switch Inst[24] {
  0, 7,                                      //  8699:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  8701:          check predicate 35
  OPC_Decode, 133, 26, 169, 2,               //  8703:          decode to VQSHRNsv4i16 using decoder 297
                                             //  8703:         }
  1, 0,                                      //  8708:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  8710:          check predicate 35
  OPC_Decode, 136, 26, 169, 2,               //  8712:          decode to VQSHRNuv4i16 using decoder 297
                                             //  8712:         }
                                             //  8712:         } // switch Inst[24]
                                             //  8712:        }
                                             //  8712:        } // switch Inst[20]
                                             //  8712:       }
  1, 0,                                      //  8717:       case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8719:        switch Inst[24] {
  0, 7,                                      //  8722:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8724:         check predicate 35
  OPC_Decode, 132, 26, 170, 2,               //  8726:         decode to VQSHRNsv2i32 using decoder 298
                                             //  8726:        }
  1, 0,                                      //  8731:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8733:         check predicate 35
  OPC_Decode, 135, 26, 170, 2,               //  8735:         decode to VQSHRNuv2i32 using decoder 298
                                             //  8735:        }
                                             //  8735:        } // switch Inst[24]
                                             //  8735:       }
                                             //  8735:       } // switch Inst[21]
                                             //  8735:      }
  10, 163, 1,                                //  8740:      case 0xa: {
  OPC_SwitchField, 21, 1,                    //  8743:       switch Inst[21] {
  0, 109,                                    //  8746:       case 0x0: {
  OPC_SwitchField, 20, 1,                    //  8748:        switch Inst[20] {
  0, 55,                                     //  8751:        case 0x0: {
  OPC_SwitchField, 24, 1,                    //  8753:         switch Inst[24] {
  0, 24,                                     //  8756:         case 0x0: {
  OPC_CheckField, 19, 1, 1,                  //  8758:          check Inst[19] == 0x1
  OPC_Scope, 11,                             //  8762:          try {
  OPC_CheckField, 16, 3, 0,                  //  8764:           check Inst[18:16] == 0x0
  OPC_CheckPredicate, 35,                    //  8768:           check predicate 35
  OPC_Decode, 207, 23, 148, 2,               //  8770:           decode to VMOVLsv8i16 using decoder 276
                                             //  8770:          } else try {
  OPC_CheckPredicate, 35,                    //  8775:           check predicate 35
  OPC_Decode, 201, 27, 171, 2,               //  8777:           decode to VSHLLsv8i16 using decoder 299
                                             //  8777:          }
                                             //  8777:         }
  1, 0,                                      //  8782:         case 0x1: {
  OPC_CheckField, 19, 1, 1,                  //  8784:          check Inst[19] == 0x1
  OPC_Scope, 11,                             //  8788:          try {
  OPC_CheckField, 16, 3, 0,                  //  8790:           check Inst[18:16] == 0x0
  OPC_CheckPredicate, 35,                    //  8794:           check predicate 35
  OPC_Decode, 210, 23, 148, 2,               //  8796:           decode to VMOVLuv8i16 using decoder 276
                                             //  8796:          } else try {
  OPC_CheckPredicate, 35,                    //  8801:           check predicate 35
  OPC_Decode, 204, 27, 171, 2,               //  8803:           decode to VSHLLuv8i16 using decoder 299
                                             //  8803:          }
                                             //  8803:         }
                                             //  8803:         } // switch Inst[24]
                                             //  8803:        }
  1, 0,                                      //  8808:        case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8810:         switch Inst[24] {
  0, 20,                                     //  8813:         case 0x0: {
  OPC_Scope, 11,                             //  8815:          try {
  OPC_CheckField, 16, 4, 0,                  //  8817:           check Inst[19:16] == 0x0
  OPC_CheckPredicate, 35,                    //  8821:           check predicate 35
  OPC_Decode, 206, 23, 148, 2,               //  8823:           decode to VMOVLsv4i32 using decoder 276
                                             //  8823:          } else try {
  OPC_CheckPredicate, 35,                    //  8828:           check predicate 35
  OPC_Decode, 200, 27, 172, 2,               //  8830:           decode to VSHLLsv4i32 using decoder 300
                                             //  8830:          }
                                             //  8830:         }
  1, 0,                                      //  8835:         case 0x1: {
  OPC_Scope, 11,                             //  8837:          try {
  OPC_CheckField, 16, 4, 0,                  //  8839:           check Inst[19:16] == 0x0
  OPC_CheckPredicate, 35,                    //  8843:           check predicate 35
  OPC_Decode, 209, 23, 148, 2,               //  8845:           decode to VMOVLuv4i32 using decoder 276
                                             //  8845:          } else try {
  OPC_CheckPredicate, 35,                    //  8850:           check predicate 35
  OPC_Decode, 203, 27, 172, 2,               //  8852:           decode to VSHLLuv4i32 using decoder 300
                                             //  8852:          }
                                             //  8852:         }
                                             //  8852:         } // switch Inst[24]
                                             //  8852:        }
                                             //  8852:        } // switch Inst[20]
                                             //  8852:       }
  1, 0,                                      //  8857:       case 0x1: {
  OPC_SwitchField, 24, 1,                    //  8859:        switch Inst[24] {
  0, 20,                                     //  8862:        case 0x0: {
  OPC_Scope, 11,                             //  8864:         try {
  OPC_CheckField, 16, 5, 0,                  //  8866:          check Inst[20:16] == 0x0
  OPC_CheckPredicate, 35,                    //  8870:          check predicate 35
  OPC_Decode, 205, 23, 148, 2,               //  8872:          decode to VMOVLsv2i64 using decoder 276
                                             //  8872:         } else try {
  OPC_CheckPredicate, 35,                    //  8877:          check predicate 35
  OPC_Decode, 199, 27, 173, 2,               //  8879:          decode to VSHLLsv2i64 using decoder 301
                                             //  8879:         }
                                             //  8879:        }
  1, 0,                                      //  8884:        case 0x1: {
  OPC_Scope, 11,                             //  8886:         try {
  OPC_CheckField, 16, 5, 0,                  //  8888:          check Inst[20:16] == 0x0
  OPC_CheckPredicate, 35,                    //  8892:          check predicate 35
  OPC_Decode, 208, 23, 148, 2,               //  8894:          decode to VMOVLuv2i64 using decoder 276
                                             //  8894:         } else try {
  OPC_CheckPredicate, 35,                    //  8899:          check predicate 35
  OPC_Decode, 202, 27, 173, 2,               //  8901:          decode to VSHLLuv2i64 using decoder 301
                                             //  8901:         }
                                             //  8901:        }
                                             //  8901:        } // switch Inst[24]
                                             //  8901:       }
                                             //  8901:       } // switch Inst[21]
                                             //  8901:      }
  12, 21,                                    //  8906:      case 0xc: {
  OPC_SwitchField, 24, 1,                    //  8908:       switch Inst[24] {
  0, 7,                                      //  8911:       case 0x0: {
  OPC_CheckPredicate, 36,                    //  8913:        check predicate 36
  OPC_Decode, 131, 19, 174, 2,               //  8915:        decode to VCVTxs2hd using decoder 302
                                             //  8915:       }
  1, 0,                                      //  8920:       case 0x1: {
  OPC_CheckPredicate, 36,                    //  8922:        check predicate 36
  OPC_Decode, 135, 19, 174, 2,               //  8924:        decode to VCVTxu2hd using decoder 302
                                             //  8924:       }
                                             //  8924:       } // switch Inst[24]
                                             //  8924:      }
  13, 21,                                    //  8929:      case 0xd: {
  OPC_SwitchField, 24, 1,                    //  8931:       switch Inst[24] {
  0, 7,                                      //  8934:       case 0x0: {
  OPC_CheckPredicate, 36,                    //  8936:        check predicate 36
  OPC_Decode, 245, 18, 174, 2,               //  8938:        decode to VCVTh2xsd using decoder 302
                                             //  8938:       }
  1, 0,                                      //  8943:       case 0x1: {
  OPC_CheckPredicate, 36,                    //  8945:        check predicate 36
  OPC_Decode, 247, 18, 174, 2,               //  8947:        decode to VCVTh2xud using decoder 302
                                             //  8947:       }
                                             //  8947:       } // switch Inst[24]
                                             //  8947:      }
  14, 52,                                    //  8952:      case 0xe: {
  OPC_Scope, 29,                             //  8954:       try {
  OPC_SwitchField, 5, 1,                     //  8956:        switch Inst[5] {
  0, 11,                                     //  8959:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8961:         check predicate 35
  OPC_CheckField, 19, 3, 0,                  //  8963:         check Inst[21:19] == 0x0
  OPC_Decode, 230, 23, 175, 2,               //  8967:         decode to VMOVv8i8 using decoder 303
                                             //  8967:        }
  1, 0,                                      //  8972:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8974:         check predicate 35
  OPC_CheckField, 19, 3, 0,                  //  8976:         check Inst[21:19] == 0x0
  OPC_Decode, 222, 23, 175, 2,               //  8980:         decode to VMOVv1i64 using decoder 303
                                             //  8980:        }
                                             //  8980:        } // switch Inst[5]
                                             //  8980:       } else try {
  OPC_SwitchField, 24, 1,                    //  8985:        switch Inst[24] {
  0, 7,                                      //  8988:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  8990:         check predicate 35
  OPC_Decode, 129, 19, 174, 2,               //  8992:         decode to VCVTxs2fd using decoder 302
                                             //  8992:        }
  1, 0,                                      //  8997:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  8999:         check predicate 35
  OPC_Decode, 133, 19, 174, 2,               //  9001:         decode to VCVTxu2fd using decoder 302
                                             //  9001:        }
                                             //  9001:        } // switch Inst[24]
                                             //  9001:       }
                                             //  9001:      }
  15, 0,                                     //  9006:      case 0xf: {
  OPC_Scope, 21,                             //  9008:       try {
  OPC_SwitchField, 24, 1,                    //  9010:        switch Inst[24] {
  0, 7,                                      //  9013:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  9015:         check predicate 35
  OPC_Decode, 236, 18, 174, 2,               //  9017:         decode to VCVTf2xsd using decoder 302
                                             //  9017:        }
  1, 0,                                      //  9022:        case 0x1: {
  OPC_CheckPredicate, 35,                    //  9024:         check predicate 35
  OPC_Decode, 238, 18, 174, 2,               //  9026:         decode to VCVTf2xud using decoder 302
                                             //  9026:        }
                                             //  9026:        } // switch Inst[24]
                                             //  9026:       } else try {
  OPC_CheckPredicate, 35,                    //  9031:        check predicate 35
  OPC_CheckField, 19, 3, 0,                  //  9033:        check Inst[21:19] == 0x0
  OPC_CheckField, 5, 1, 0,                   //  9037:        check Inst[5] == 0x0
  OPC_Decode, 223, 23, 175, 2,               //  9041:        decode to VMOVv2f32 using decoder 303
                                             //  9041:       }
                                             //  9041:      }
                                             //  9041:      } // switch Inst[11:8]
                                             //  9041:     } else try {
  OPC_SwitchField, 5, 1,                     //  9046:      switch Inst[5] {
  0, 56,                                     //  9049:      case 0x0: {
  OPC_CheckField, 19, 3, 0,                  //  9051:       check Inst[21:19] == 0x0
  OPC_Scope, 43,                             //  9055:       try {
  OPC_SwitchField, 8, 1,                     //  9057:        switch Inst[8] {
  0, 11,                                     //  9060:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  9062:         check predicate 35
  OPC_CheckField, 10, 2, 2,                  //  9064:         check Inst[11:10] == 0x2
  OPC_Decode, 227, 23, 175, 2,               //  9068:         decode to VMOVv4i16 using decoder 303
                                             //  9068:        }
  1, 0,                                      //  9073:        case 0x1: {
  OPC_SwitchField, 11, 1,                    //  9075:         switch Inst[11] {
  0, 7,                                      //  9078:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  9080:          check predicate 35
  OPC_Decode, 192, 24, 175, 2,               //  9082:          decode to VORRiv2i32 using decoder 303
                                             //  9082:         }
  1, 0,                                      //  9087:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  9089:          check predicate 35
  OPC_CheckField, 10, 1, 0,                  //  9091:          check Inst[10] == 0x0
  OPC_Decode, 193, 24, 175, 2,               //  9095:          decode to VORRiv4i16 using decoder 303
                                             //  9095:         }
                                             //  9095:         } // switch Inst[11]
                                             //  9095:        }
                                             //  9095:        } // switch Inst[8]
                                             //  9095:       } else try {
  OPC_CheckPredicate, 35,                    //  9100:        check predicate 35
  OPC_Decode, 224, 23, 175, 2,               //  9102:        decode to VMOVv2i32 using decoder 303
                                             //  9102:       }
                                             //  9102:      }
  1, 0,                                      //  9107:      case 0x1: {
  OPC_CheckField, 19, 3, 0,                  //  9109:       check Inst[21:19] == 0x0
  OPC_Scope, 43,                             //  9113:       try {
  OPC_SwitchField, 8, 1,                     //  9115:        switch Inst[8] {
  0, 11,                                     //  9118:        case 0x0: {
  OPC_CheckPredicate, 35,                    //  9120:         check predicate 35
  OPC_CheckField, 10, 2, 2,                  //  9122:         check Inst[11:10] == 0x2
  OPC_Decode, 164, 24, 175, 2,               //  9126:         decode to VMVNv4i16 using decoder 303
                                             //  9126:        }
  1, 0,                                      //  9131:        case 0x1: {
  OPC_SwitchField, 11, 1,                    //  9133:         switch Inst[11] {
  0, 7,                                      //  9136:         case 0x0: {
  OPC_CheckPredicate, 35,                    //  9138:          check predicate 35
  OPC_Decode, 150, 17, 175, 2,               //  9140:          decode to VBICiv2i32 using decoder 303
                                             //  9140:         }
  1, 0,                                      //  9145:         case 0x1: {
  OPC_CheckPredicate, 35,                    //  9147:          check predicate 35
  OPC_CheckField, 10, 1, 0,                  //  9149:          check Inst[10] == 0x0
  OPC_Decode, 151, 17, 175, 2,               //  9153:          decode to VBICiv4i16 using decoder 303
                                             //  9153:         }
                                             //  9153:         } // switch Inst[11]
                                             //  9153:        }
                                             //  9153:        } // switch Inst[8]
                                             //  9153:       } else try {
  OPC_CheckPredicate, 35,                    //  9158:        check predicate 35
  OPC_Decode, 163, 24, 175, 2,               //  9160:        decode to VMVNv2i32 using decoder 303
                                             //  9160:       }
                                             //  9160:      }
                                             //  9160:      } // switch Inst[5]
                                             //  9160:     }
                                             //  9160:    }
  1, 0,                                      //  9165:    case 0x1: {
  OPC_SwitchField, 8, 4,                     //  9167:     switch Inst[11:8] {
  0, 23,                                     //  9170:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  9172:      switch Inst[31:24] {
  242, 1, 7,                                 //  9175:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9178:       check predicate 35
  OPC_Decode, 233, 27, 176, 2,               //  9180:       decode to VSHRsv1i64 using decoder 304
                                             //  9180:      }
  243, 1, 0,                                 //  9185:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9188:       check predicate 35
  OPC_Decode, 241, 27, 176, 2,               //  9190:       decode to VSHRuv1i64 using decoder 304
                                             //  9190:      }
                                             //  9190:      } // switch Inst[31:24]
                                             //  9190:     }
  1, 23,                                     //  9195:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  9197:      switch Inst[31:24] {
  242, 1, 7,                                 //  9200:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9203:       check predicate 35
  OPC_Decode, 142, 28, 177, 2,               //  9205:       decode to VSRAsv1i64 using decoder 305
                                             //  9205:      }
  243, 1, 0,                                 //  9210:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9213:       check predicate 35
  OPC_Decode, 150, 28, 177, 2,               //  9215:       decode to VSRAuv1i64 using decoder 305
                                             //  9215:      }
                                             //  9215:      } // switch Inst[31:24]
                                             //  9215:     }
  2, 23,                                     //  9220:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  9222:      switch Inst[31:24] {
  242, 1, 7,                                 //  9225:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9228:       check predicate 35
  OPC_Decode, 131, 27, 176, 2,               //  9230:       decode to VRSHRsv1i64 using decoder 304
                                             //  9230:      }
  243, 1, 0,                                 //  9235:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9238:       check predicate 35
  OPC_Decode, 139, 27, 176, 2,               //  9240:       decode to VRSHRuv1i64 using decoder 304
                                             //  9240:      }
                                             //  9240:      } // switch Inst[31:24]
                                             //  9240:     }
  3, 23,                                     //  9245:     case 0x3: {
  OPC_SwitchField, 24, 8,                    //  9247:      switch Inst[31:24] {
  242, 1, 7,                                 //  9250:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9253:       check predicate 35
  OPC_Decode, 157, 27, 177, 2,               //  9255:       decode to VRSRAsv1i64 using decoder 305
                                             //  9255:      }
  243, 1, 0,                                 //  9260:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9263:       check predicate 35
  OPC_Decode, 165, 27, 177, 2,               //  9265:       decode to VRSRAuv1i64 using decoder 305
                                             //  9265:      }
                                             //  9265:      } // switch Inst[31:24]
                                             //  9265:     }
  4, 12,                                     //  9270:     case 0x4: {
  OPC_CheckPredicate, 35,                    //  9272:      check predicate 35
  OPC_CheckField, 24, 8, 243, 1,             //  9274:      check Inst[31:24] == 0xf3
  OPC_Decode, 158, 28, 177, 2,               //  9279:      decode to VSRIv1i64 using decoder 305
                                             //  9279:     }
  5, 23,                                     //  9284:     case 0x5: {
  OPC_SwitchField, 24, 8,                    //  9286:      switch Inst[31:24] {
  242, 1, 7,                                 //  9289:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9292:       check predicate 35
  OPC_Decode, 206, 27, 178, 2,               //  9294:       decode to VSHLiv1i64 using decoder 306
                                             //  9294:      }
  243, 1, 0,                                 //  9299:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9302:       check predicate 35
  OPC_Decode, 255, 27, 179, 2,               //  9304:       decode to VSLIv1i64 using decoder 307
                                             //  9304:      }
                                             //  9304:      } // switch Inst[31:24]
                                             //  9304:     }
  6, 12,                                     //  9309:     case 0x6: {
  OPC_CheckPredicate, 35,                    //  9311:      check predicate 35
  OPC_CheckField, 24, 8, 243, 1,             //  9313:      check Inst[31:24] == 0xf3
  OPC_Decode, 229, 25, 178, 2,               //  9318:      decode to VQSHLsuv1i64 using decoder 306
                                             //  9318:     }
  7, 0,                                      //  9323:     case 0x7: {
  OPC_SwitchField, 24, 8,                    //  9325:      switch Inst[31:24] {
  242, 1, 7,                                 //  9328:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9331:       check predicate 35
  OPC_Decode, 221, 25, 178, 2,               //  9333:       decode to VQSHLsiv1i64 using decoder 306
                                             //  9333:      }
  243, 1, 0,                                 //  9338:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9341:       check predicate 35
  OPC_Decode, 245, 25, 178, 2,               //  9343:       decode to VQSHLuiv1i64 using decoder 306
                                             //  9343:      }
                                             //  9343:      } // switch Inst[31:24]
                                             //  9343:     }
                                             //  9343:     } // switch Inst[11:8]
                                             //  9343:    }
                                             //  9343:    } // switch Inst[7]
                                             //  9343:   }
                                             //  9343:   } // switch Inst[23]
                                             //  9343:  }
  1, 0,                                      //  9348:  case 0x1: {
  OPC_SwitchField, 23, 1,                    //  9350:   switch Inst[23] {
  0, 203, 9,                                 //  9353:   case 0x0: {
  OPC_SwitchField, 8, 4,                     //  9356:    switch Inst[11:8] {
  0, 103,                                    //  9359:    case 0x0: {
  OPC_SwitchField, 20, 2,                    //  9361:     switch Inst[21:20] {
  0, 23,                                     //  9364:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  9366:      switch Inst[31:24] {
  242, 1, 7,                                 //  9369:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9372:       check predicate 35
  OPC_Decode, 248, 24, 239, 1,               //  9374:       decode to VQADDsv16i8 using decoder 239
                                             //  9374:      }
  243, 1, 0,                                 //  9379:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9382:       check predicate 35
  OPC_Decode, 128, 25, 239, 1,               //  9384:       decode to VQADDuv16i8 using decoder 239
                                             //  9384:      }
                                             //  9384:      } // switch Inst[31:24]
                                             //  9384:     }
  1, 23,                                     //  9389:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  9391:      switch Inst[31:24] {
  242, 1, 7,                                 //  9394:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9397:       check predicate 35
  OPC_Decode, 254, 24, 239, 1,               //  9399:       decode to VQADDsv8i16 using decoder 239
                                             //  9399:      }
  243, 1, 0,                                 //  9404:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9407:       check predicate 35
  OPC_Decode, 134, 25, 239, 1,               //  9409:       decode to VQADDuv8i16 using decoder 239
                                             //  9409:      }
                                             //  9409:      } // switch Inst[31:24]
                                             //  9409:     }
  2, 23,                                     //  9414:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  9416:      switch Inst[31:24] {
  242, 1, 7,                                 //  9419:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9422:       check predicate 35
  OPC_Decode, 253, 24, 239, 1,               //  9424:       decode to VQADDsv4i32 using decoder 239
                                             //  9424:      }
  243, 1, 0,                                 //  9429:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9432:       check predicate 35
  OPC_Decode, 133, 25, 239, 1,               //  9434:       decode to VQADDuv4i32 using decoder 239
                                             //  9434:      }
                                             //  9434:      } // switch Inst[31:24]
                                             //  9434:     }
  3, 0,                                      //  9439:     case 0x3: {
  OPC_SwitchField, 24, 8,                    //  9441:      switch Inst[31:24] {
  242, 1, 7,                                 //  9444:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9447:       check predicate 35
  OPC_Decode, 251, 24, 239, 1,               //  9449:       decode to VQADDsv2i64 using decoder 239
                                             //  9449:      }
  243, 1, 0,                                 //  9454:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9457:       check predicate 35
  OPC_Decode, 131, 25, 239, 1,               //  9459:       decode to VQADDuv2i64 using decoder 239
                                             //  9459:      }
                                             //  9459:      } // switch Inst[31:24]
                                             //  9459:     }
                                             //  9459:     } // switch Inst[21:20]
                                             //  9459:    }
  1, 103,                                    //  9464:    case 0x1: {
  OPC_SwitchField, 20, 2,                    //  9466:     switch Inst[21:20] {
  0, 23,                                     //  9469:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  9471:      switch Inst[31:24] {
  242, 1, 7,                                 //  9474:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9477:       check predicate 35
  OPC_Decode, 144, 17, 239, 1,               //  9479:       decode to VANDq using decoder 239
                                             //  9479:      }
  243, 1, 0,                                 //  9484:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9487:       check predicate 35
  OPC_Decode, 153, 19, 239, 1,               //  9489:       decode to VEORq using decoder 239
                                             //  9489:      }
                                             //  9489:      } // switch Inst[31:24]
                                             //  9489:     }
  1, 23,                                     //  9494:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  9496:      switch Inst[31:24] {
  242, 1, 7,                                 //  9499:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9502:       check predicate 35
  OPC_Decode, 154, 17, 239, 1,               //  9504:       decode to VBICq using decoder 239
                                             //  9504:      }
  243, 1, 0,                                 //  9509:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9512:       check predicate 35
  OPC_Decode, 160, 17, 247, 1,               //  9514:       decode to VBSLq using decoder 247
                                             //  9514:      }
                                             //  9514:      } // switch Inst[31:24]
                                             //  9514:     }
  2, 23,                                     //  9519:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  9521:      switch Inst[31:24] {
  242, 1, 7,                                 //  9524:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9527:       check predicate 35
  OPC_Decode, 196, 24, 239, 1,               //  9529:       decode to VORRq using decoder 239
                                             //  9529:      }
  243, 1, 0,                                 //  9534:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9537:       check predicate 35
  OPC_Decode, 158, 17, 247, 1,               //  9539:       decode to VBITq using decoder 247
                                             //  9539:      }
                                             //  9539:      } // switch Inst[31:24]
                                             //  9539:     }
  3, 0,                                      //  9544:     case 0x3: {
  OPC_SwitchField, 24, 8,                    //  9546:      switch Inst[31:24] {
  242, 1, 7,                                 //  9549:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9552:       check predicate 35
  OPC_Decode, 190, 24, 239, 1,               //  9554:       decode to VORNq using decoder 239
                                             //  9554:      }
  243, 1, 0,                                 //  9559:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9562:       check predicate 35
  OPC_Decode, 156, 17, 247, 1,               //  9564:       decode to VBIFq using decoder 247
                                             //  9564:      }
                                             //  9564:      } // switch Inst[31:24]
                                             //  9564:     }
                                             //  9564:     } // switch Inst[21:20]
                                             //  9564:    }
  2, 103,                                    //  9569:    case 0x2: {
  OPC_SwitchField, 20, 2,                    //  9571:     switch Inst[21:20] {
  0, 23,                                     //  9574:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  9576:      switch Inst[31:24] {
  242, 1, 7,                                 //  9579:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9582:       check predicate 35
  OPC_Decode, 141, 26, 239, 1,               //  9584:       decode to VQSUBsv16i8 using decoder 239
                                             //  9584:      }
  243, 1, 0,                                 //  9589:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9592:       check predicate 35
  OPC_Decode, 149, 26, 239, 1,               //  9594:       decode to VQSUBuv16i8 using decoder 239
                                             //  9594:      }
                                             //  9594:      } // switch Inst[31:24]
                                             //  9594:     }
  1, 23,                                     //  9599:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  9601:      switch Inst[31:24] {
  242, 1, 7,                                 //  9604:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9607:       check predicate 35
  OPC_Decode, 147, 26, 239, 1,               //  9609:       decode to VQSUBsv8i16 using decoder 239
                                             //  9609:      }
  243, 1, 0,                                 //  9614:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9617:       check predicate 35
  OPC_Decode, 155, 26, 239, 1,               //  9619:       decode to VQSUBuv8i16 using decoder 239
                                             //  9619:      }
                                             //  9619:      } // switch Inst[31:24]
                                             //  9619:     }
  2, 23,                                     //  9624:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  9626:      switch Inst[31:24] {
  242, 1, 7,                                 //  9629:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9632:       check predicate 35
  OPC_Decode, 146, 26, 239, 1,               //  9634:       decode to VQSUBsv4i32 using decoder 239
                                             //  9634:      }
  243, 1, 0,                                 //  9639:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9642:       check predicate 35
  OPC_Decode, 154, 26, 239, 1,               //  9644:       decode to VQSUBuv4i32 using decoder 239
                                             //  9644:      }
                                             //  9644:      } // switch Inst[31:24]
                                             //  9644:     }
  3, 0,                                      //  9649:     case 0x3: {
  OPC_SwitchField, 24, 8,                    //  9651:      switch Inst[31:24] {
  242, 1, 7,                                 //  9654:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9657:       check predicate 35
  OPC_Decode, 144, 26, 239, 1,               //  9659:       decode to VQSUBsv2i64 using decoder 239
                                             //  9659:      }
  243, 1, 0,                                 //  9664:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9667:       check predicate 35
  OPC_Decode, 152, 26, 239, 1,               //  9669:       decode to VQSUBuv2i64 using decoder 239
                                             //  9669:      }
                                             //  9669:      } // switch Inst[31:24]
                                             //  9669:     }
                                             //  9669:     } // switch Inst[21:20]
                                             //  9669:    }
  3, 78,                                     //  9674:    case 0x3: {
  OPC_SwitchField, 20, 2,                    //  9676:     switch Inst[21:20] {
  0, 23,                                     //  9679:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  9681:      switch Inst[31:24] {
  242, 1, 7,                                 //  9684:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9687:       check predicate 35
  OPC_Decode, 191, 17, 239, 1,               //  9689:       decode to VCGEsv16i8 using decoder 239
                                             //  9689:      }
  243, 1, 0,                                 //  9694:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9697:       check predicate 35
  OPC_Decode, 197, 17, 239, 1,               //  9699:       decode to VCGEuv16i8 using decoder 239
                                             //  9699:      }
                                             //  9699:      } // switch Inst[31:24]
                                             //  9699:     }
  1, 23,                                     //  9704:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  9706:      switch Inst[31:24] {
  242, 1, 7,                                 //  9709:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9712:       check predicate 35
  OPC_Decode, 195, 17, 239, 1,               //  9714:       decode to VCGEsv8i16 using decoder 239
                                             //  9714:      }
  243, 1, 0,                                 //  9719:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9722:       check predicate 35
  OPC_Decode, 201, 17, 239, 1,               //  9724:       decode to VCGEuv8i16 using decoder 239
                                             //  9724:      }
                                             //  9724:      } // switch Inst[31:24]
                                             //  9724:     }
  2, 0,                                      //  9729:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  9731:      switch Inst[31:24] {
  242, 1, 7,                                 //  9734:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9737:       check predicate 35
  OPC_Decode, 194, 17, 239, 1,               //  9739:       decode to VCGEsv4i32 using decoder 239
                                             //  9739:      }
  243, 1, 0,                                 //  9744:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9747:       check predicate 35
  OPC_Decode, 200, 17, 239, 1,               //  9749:       decode to VCGEuv4i32 using decoder 239
                                             //  9749:      }
                                             //  9749:      } // switch Inst[31:24]
                                             //  9749:     }
                                             //  9749:     } // switch Inst[21:20]
                                             //  9749:    }
  4, 103,                                    //  9754:    case 0x4: {
  OPC_SwitchField, 20, 2,                    //  9756:     switch Inst[21:20] {
  0, 23,                                     //  9759:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  9761:      switch Inst[31:24] {
  242, 1, 7,                                 //  9764:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9767:       check predicate 35
  OPC_Decode, 236, 25, 243, 1,               //  9769:       decode to VQSHLsv16i8 using decoder 243
                                             //  9769:      }
  243, 1, 0,                                 //  9774:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9777:       check predicate 35
  OPC_Decode, 252, 25, 243, 1,               //  9779:       decode to VQSHLuv16i8 using decoder 243
                                             //  9779:      }
                                             //  9779:      } // switch Inst[31:24]
                                             //  9779:     }
  1, 23,                                     //  9784:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  9786:      switch Inst[31:24] {
  242, 1, 7,                                 //  9789:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9792:       check predicate 35
  OPC_Decode, 242, 25, 243, 1,               //  9794:       decode to VQSHLsv8i16 using decoder 243
                                             //  9794:      }
  243, 1, 0,                                 //  9799:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9802:       check predicate 35
  OPC_Decode, 130, 26, 243, 1,               //  9804:       decode to VQSHLuv8i16 using decoder 243
                                             //  9804:      }
                                             //  9804:      } // switch Inst[31:24]
                                             //  9804:     }
  2, 23,                                     //  9809:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  9811:      switch Inst[31:24] {
  242, 1, 7,                                 //  9814:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9817:       check predicate 35
  OPC_Decode, 241, 25, 243, 1,               //  9819:       decode to VQSHLsv4i32 using decoder 243
                                             //  9819:      }
  243, 1, 0,                                 //  9824:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9827:       check predicate 35
  OPC_Decode, 129, 26, 243, 1,               //  9829:       decode to VQSHLuv4i32 using decoder 243
                                             //  9829:      }
                                             //  9829:      } // switch Inst[31:24]
                                             //  9829:     }
  3, 0,                                      //  9834:     case 0x3: {
  OPC_SwitchField, 24, 8,                    //  9836:      switch Inst[31:24] {
  242, 1, 7,                                 //  9839:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9842:       check predicate 35
  OPC_Decode, 239, 25, 243, 1,               //  9844:       decode to VQSHLsv2i64 using decoder 243
                                             //  9844:      }
  243, 1, 0,                                 //  9849:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9852:       check predicate 35
  OPC_Decode, 255, 25, 243, 1,               //  9854:       decode to VQSHLuv2i64 using decoder 243
                                             //  9854:      }
                                             //  9854:      } // switch Inst[31:24]
                                             //  9854:     }
                                             //  9854:     } // switch Inst[21:20]
                                             //  9854:    }
  5, 103,                                    //  9859:    case 0x5: {
  OPC_SwitchField, 20, 2,                    //  9861:     switch Inst[21:20] {
  0, 23,                                     //  9864:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  9866:      switch Inst[31:24] {
  242, 1, 7,                                 //  9869:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9872:       check predicate 35
  OPC_Decode, 195, 25, 243, 1,               //  9874:       decode to VQRSHLsv16i8 using decoder 243
                                             //  9874:      }
  243, 1, 0,                                 //  9879:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9882:       check predicate 35
  OPC_Decode, 203, 25, 243, 1,               //  9884:       decode to VQRSHLuv16i8 using decoder 243
                                             //  9884:      }
                                             //  9884:      } // switch Inst[31:24]
                                             //  9884:     }
  1, 23,                                     //  9889:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  9891:      switch Inst[31:24] {
  242, 1, 7,                                 //  9894:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9897:       check predicate 35
  OPC_Decode, 201, 25, 243, 1,               //  9899:       decode to VQRSHLsv8i16 using decoder 243
                                             //  9899:      }
  243, 1, 0,                                 //  9904:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9907:       check predicate 35
  OPC_Decode, 209, 25, 243, 1,               //  9909:       decode to VQRSHLuv8i16 using decoder 243
                                             //  9909:      }
                                             //  9909:      } // switch Inst[31:24]
                                             //  9909:     }
  2, 23,                                     //  9914:     case 0x2: {
  OPC_SwitchField, 24, 8,                    //  9916:      switch Inst[31:24] {
  242, 1, 7,                                 //  9919:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9922:       check predicate 35
  OPC_Decode, 200, 25, 243, 1,               //  9924:       decode to VQRSHLsv4i32 using decoder 243
                                             //  9924:      }
  243, 1, 0,                                 //  9929:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9932:       check predicate 35
  OPC_Decode, 208, 25, 243, 1,               //  9934:       decode to VQRSHLuv4i32 using decoder 243
                                             //  9934:      }
                                             //  9934:      } // switch Inst[31:24]
                                             //  9934:     }
  3, 0,                                      //  9939:     case 0x3: {
  OPC_SwitchField, 24, 8,                    //  9941:      switch Inst[31:24] {
  242, 1, 7,                                 //  9944:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9947:       check predicate 35
  OPC_Decode, 198, 25, 243, 1,               //  9949:       decode to VQRSHLsv2i64 using decoder 243
                                             //  9949:      }
  243, 1, 0,                                 //  9954:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9957:       check predicate 35
  OPC_Decode, 206, 25, 243, 1,               //  9959:       decode to VQRSHLuv2i64 using decoder 243
                                             //  9959:      }
                                             //  9959:      } // switch Inst[31:24]
                                             //  9959:     }
                                             //  9959:     } // switch Inst[21:20]
                                             //  9959:    }
  6, 78,                                     //  9964:    case 0x6: {
  OPC_SwitchField, 20, 2,                    //  9966:     switch Inst[21:20] {
  0, 23,                                     //  9969:     case 0x0: {
  OPC_SwitchField, 24, 8,                    //  9971:      switch Inst[31:24] {
  242, 1, 7,                                 //  9974:      case 0xf2: {
  OPC_CheckPredicate, 35,                    //  9977:       check predicate 35
  OPC_Decode, 254, 22, 239, 1,               //  9979:       decode to VMINsv16i8 using decoder 239
                                             //  9979:      }
  243, 1, 0,                                 //  9984:      case 0xf3: {
  OPC_CheckPredicate, 35,                    //  9987:       check predicate 35
  OPC_Decode, 132, 23, 239, 1,               //  9989:       decode to VMINuv16i8 using decoder 239
                                             //  9989:      }
                                             //  9989:      } // switch Inst[31:24]
                                             //  9989:     }
  1, 23,                                     //  9994:     case 0x1: {
  OPC_SwitchField, 24, 8,                    //  9996:      switch Inst[31:24] {
  242, 1, 7,                                 //  9999:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 10002:       check predicate 35
  OPC_Decode, 130, 23, 239, 1,               // 10004:       decode to VMINsv8i16 using decoder 239
                                             // 10004:      }
  243, 1, 0,                                 // 10009:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 10012:       check predicate 35
  OPC_Decode, 136, 23, 239, 1,               // 10014:       decode to VMINuv8i16 using decoder 239
                                             // 10014:      }
                                             // 10014:      } // switch Inst[31:24]
                                             // 10014:     }
  2, 0,                                      // 10019:     case 0x2: {
  OPC_SwitchField, 24, 8,                    // 10021:      switch Inst[31:24] {
  242, 1, 7,                                 // 10024:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 10027:       check predicate 35
  OPC_Decode, 129, 23, 239, 1,               // 10029:       decode to VMINsv4i32 using decoder 239
                                             // 10029:      }
  243, 1, 0,                                 // 10034:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 10037:       check predicate 35
  OPC_Decode, 135, 23, 239, 1,               // 10039:       decode to VMINuv4i32 using decoder 239
                                             // 10039:      }
                                             // 10039:      } // switch Inst[31:24]
                                             // 10039:     }
                                             // 10039:     } // switch Inst[21:20]
                                             // 10039:    }
  7, 78,                                     // 10044:    case 0x7: {
  OPC_SwitchField, 20, 2,                    // 10046:     switch Inst[21:20] {
  0, 23,                                     // 10049:     case 0x0: {
  OPC_SwitchField, 24, 8,                    // 10051:      switch Inst[31:24] {
  242, 1, 7,                                 // 10054:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 10057:       check predicate 35
  OPC_Decode, 186, 16, 247, 1,               // 10059:       decode to VABAsv16i8 using decoder 247
                                             // 10059:      }
  243, 1, 0,                                 // 10064:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 10067:       check predicate 35
  OPC_Decode, 192, 16, 247, 1,               // 10069:       decode to VABAuv16i8 using decoder 247
                                             // 10069:      }
                                             // 10069:      } // switch Inst[31:24]
                                             // 10069:     }
  1, 23,                                     // 10074:     case 0x1: {
  OPC_SwitchField, 24, 8,                    // 10076:      switch Inst[31:24] {
  242, 1, 7,                                 // 10079:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 10082:       check predicate 35
  OPC_Decode, 190, 16, 247, 1,               // 10084:       decode to VABAsv8i16 using decoder 247
                                             // 10084:      }
  243, 1, 0,                                 // 10089:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 10092:       check predicate 35
  OPC_Decode, 196, 16, 247, 1,               // 10094:       decode to VABAuv8i16 using decoder 247
                                             // 10094:      }
                                             // 10094:      } // switch Inst[31:24]
                                             // 10094:     }
  2, 0,                                      // 10099:     case 0x2: {
  OPC_SwitchField, 24, 8,                    // 10101:      switch Inst[31:24] {
  242, 1, 7,                                 // 10104:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 10107:       check predicate 35
  OPC_Decode, 189, 16, 247, 1,               // 10109:       decode to VABAsv4i32 using decoder 247
                                             // 10109:      }
  243, 1, 0,                                 // 10114:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 10117:       check predicate 35
  OPC_Decode, 195, 16, 247, 1,               // 10119:       decode to VABAuv4i32 using decoder 247
                                             // 10119:      }
                                             // 10119:      } // switch Inst[31:24]
                                             // 10119:     }
                                             // 10119:     } // switch Inst[21:20]
                                             // 10119:    }
  8, 78,                                     // 10124:    case 0x8: {
  OPC_SwitchField, 20, 2,                    // 10126:     switch Inst[21:20] {
  0, 23,                                     // 10129:     case 0x0: {
  OPC_SwitchField, 24, 8,                    // 10131:      switch Inst[31:24] {
  242, 1, 7,                                 // 10134:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 10137:       check predicate 35
  OPC_Decode, 143, 31, 239, 1,               // 10139:       decode to VTSTv16i8 using decoder 239
                                             // 10139:      }
  243, 1, 0,                                 // 10144:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 10147:       check predicate 35
  OPC_Decode, 171, 17, 239, 1,               // 10149:       decode to VCEQv16i8 using decoder 239
                                             // 10149:      }
                                             // 10149:      } // switch Inst[31:24]
                                             // 10149:     }
  1, 23,                                     // 10154:     case 0x1: {
  OPC_SwitchField, 24, 8,                    // 10156:      switch Inst[31:24] {
  242, 1, 7,                                 // 10159:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 10162:       check predicate 35
  OPC_Decode, 147, 31, 239, 1,               // 10164:       decode to VTSTv8i16 using decoder 239
                                             // 10164:      }
  243, 1, 0,                                 // 10169:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 10172:       check predicate 35
  OPC_Decode, 175, 17, 239, 1,               // 10174:       decode to VCEQv8i16 using decoder 239
                                             // 10174:      }
                                             // 10174:      } // switch Inst[31:24]
                                             // 10174:     }
  2, 0,                                      // 10179:     case 0x2: {
  OPC_SwitchField, 24, 8,                    // 10181:      switch Inst[31:24] {
  242, 1, 7,                                 // 10184:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 10187:       check predicate 35
  OPC_Decode, 146, 31, 239, 1,               // 10189:       decode to VTSTv4i32 using decoder 239
                                             // 10189:      }
  243, 1, 0,                                 // 10194:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 10197:       check predicate 35
  OPC_Decode, 174, 17, 239, 1,               // 10199:       decode to VCEQv4i32 using decoder 239
                                             // 10199:      }
                                             // 10199:      } // switch Inst[31:24]
                                             // 10199:     }
                                             // 10199:     } // switch Inst[21:20]
                                             // 10199:    }
  9, 56,                                     // 10204:    case 0x9: {
  OPC_SwitchField, 20, 2,                    // 10206:     switch Inst[21:20] {
  0, 23,                                     // 10209:     case 0x0: {
  OPC_SwitchField, 24, 8,                    // 10211:      switch Inst[31:24] {
  242, 1, 7,                                 // 10214:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 10217:       check predicate 35
  OPC_Decode, 155, 24, 239, 1,               // 10219:       decode to VMULv16i8 using decoder 239
                                             // 10219:      }
  243, 1, 0,                                 // 10224:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 10227:       check predicate 35
  OPC_Decode, 146, 24, 239, 1,               // 10229:       decode to VMULpq using decoder 239
                                             // 10229:      }
                                             // 10229:      } // switch Inst[31:24]
                                             // 10229:     }
  1, 12,                                     // 10234:     case 0x1: {
  OPC_CheckPredicate, 35,                    // 10236:      check predicate 35
  OPC_CheckField, 24, 8, 242, 1,             // 10238:      check Inst[31:24] == 0xf2
  OPC_Decode, 159, 24, 239, 1,               // 10243:      decode to VMULv8i16 using decoder 239
                                             // 10243:     }
  2, 0,                                      // 10248:     case 0x2: {
  OPC_CheckPredicate, 35,                    // 10250:      check predicate 35
  OPC_CheckField, 24, 8, 242, 1,             // 10252:      check Inst[31:24] == 0xf2
  OPC_Decode, 158, 24, 239, 1,               // 10257:      decode to VMULv4i32 using decoder 239
                                             // 10257:     }
                                             // 10257:     } // switch Inst[21:20]
                                             // 10257:    }
  11, 31,                                    // 10262:    case 0xb: {
  OPC_SwitchField, 20, 2,                    // 10264:     switch Inst[21:20] {
  1, 12,                                     // 10267:     case 0x1: {
  OPC_CheckPredicate, 37,                    // 10269:      check predicate 37
  OPC_CheckField, 24, 8, 243, 1,             // 10271:      check Inst[31:24] == 0xf3
  OPC_Decode, 178, 25, 247, 1,               // 10276:      decode to VQRDMLAHv8i16 using decoder 247
                                             // 10276:     }
  2, 0,                                      // 10281:     case 0x2: {
  OPC_CheckPredicate, 37,                    // 10283:      check predicate 37
  OPC_CheckField, 24, 8, 243, 1,             // 10285:      check Inst[31:24] == 0xf3
  OPC_Decode, 177, 25, 247, 1,               // 10290:      decode to VQRDMLAHv4i32 using decoder 247
                                             // 10290:     }
                                             // 10290:     } // switch Inst[21:20]
                                             // 10290:    }
  12, 81,                                    // 10295:    case 0xc: {
  OPC_SwitchField, 20, 2,                    // 10297:     switch Inst[21:20] {
  0, 12,                                     // 10300:     case 0x0: {
  OPC_CheckPredicate, 41,                    // 10302:      check predicate 41
  OPC_CheckField, 24, 8, 242, 1,             // 10304:      check Inst[31:24] == 0xf2
  OPC_Decode, 169, 19, 247, 1,               // 10309:      decode to VFMAfq using decoder 247
                                             // 10309:     }
  1, 23,                                     // 10314:     case 0x1: {
  OPC_SwitchField, 24, 8,                    // 10316:      switch Inst[31:24] {
  242, 1, 7,                                 // 10319:      case 0xf2: {
  OPC_CheckPredicate, 36,                    // 10322:       check predicate 36
  OPC_Decode, 171, 19, 247, 1,               // 10324:       decode to VFMAhq using decoder 247
                                             // 10324:      }
  243, 1, 0,                                 // 10329:      case 0xf3: {
  OPC_CheckPredicate, 37,                    // 10332:       check predicate 37
  OPC_Decode, 186, 25, 247, 1,               // 10334:       decode to VQRDMLSHv8i16 using decoder 247
                                             // 10334:      }
                                             // 10334:      } // switch Inst[31:24]
                                             // 10334:     }
  2, 23,                                     // 10339:     case 0x2: {
  OPC_SwitchField, 24, 8,                    // 10341:      switch Inst[31:24] {
  242, 1, 7,                                 // 10344:      case 0xf2: {
  OPC_CheckPredicate, 41,                    // 10347:       check predicate 41
  OPC_Decode, 180, 19, 247, 1,               // 10349:       decode to VFMSfq using decoder 247
                                             // 10349:      }
  243, 1, 0,                                 // 10354:      case 0xf3: {
  OPC_CheckPredicate, 37,                    // 10357:       check predicate 37
  OPC_Decode, 185, 25, 247, 1,               // 10359:       decode to VQRDMLSHv4i32 using decoder 247
                                             // 10359:      }
                                             // 10359:      } // switch Inst[31:24]
                                             // 10359:     }
  3, 0,                                      // 10364:     case 0x3: {
  OPC_CheckPredicate, 36,                    // 10366:      check predicate 36
  OPC_CheckField, 24, 8, 242, 1,             // 10368:      check Inst[31:24] == 0xf2
  OPC_Decode, 182, 19, 247, 1,               // 10373:      decode to VFMShq using decoder 247
                                             // 10373:     }
                                             // 10373:     } // switch Inst[21:20]
                                             // 10373:    }
  13, 81,                                    // 10378:    case 0xd: {
  OPC_SwitchField, 20, 2,                    // 10380:     switch Inst[21:20] {
  0, 23,                                     // 10383:     case 0x0: {
  OPC_SwitchField, 24, 8,                    // 10385:      switch Inst[31:24] {
  242, 1, 7,                                 // 10388:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 10391:       check predicate 35
  OPC_Decode, 152, 23, 247, 1,               // 10393:       decode to VMLAfq using decoder 247
                                             // 10393:      }
  243, 1, 0,                                 // 10398:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 10401:       check predicate 35
  OPC_Decode, 142, 24, 239, 1,               // 10403:       decode to VMULfq using decoder 239
                                             // 10403:      }
                                             // 10403:      } // switch Inst[31:24]
                                             // 10403:     }
  1, 23,                                     // 10408:     case 0x1: {
  OPC_SwitchField, 24, 8,                    // 10410:      switch Inst[31:24] {
  242, 1, 7,                                 // 10413:      case 0xf2: {
  OPC_CheckPredicate, 36,                    // 10416:       check predicate 36
  OPC_Decode, 154, 23, 247, 1,               // 10418:       decode to VMLAhq using decoder 247
                                             // 10418:      }
  243, 1, 0,                                 // 10423:      case 0xf3: {
  OPC_CheckPredicate, 36,                    // 10426:       check predicate 36
  OPC_Decode, 144, 24, 239, 1,               // 10428:       decode to VMULhq using decoder 239
                                             // 10428:      }
                                             // 10428:      } // switch Inst[31:24]
                                             // 10428:     }
  2, 12,                                     // 10433:     case 0x2: {
  OPC_CheckPredicate, 35,                    // 10435:      check predicate 35
  OPC_CheckField, 24, 8, 242, 1,             // 10437:      check Inst[31:24] == 0xf2
  OPC_Decode, 183, 23, 247, 1,               // 10442:      decode to VMLSfq using decoder 247
                                             // 10442:     }
  3, 0,                                      // 10447:     case 0x3: {
  OPC_CheckPredicate, 36,                    // 10449:      check predicate 36
  OPC_CheckField, 24, 8, 242, 1,             // 10451:      check Inst[31:24] == 0xf2
  OPC_Decode, 185, 23, 247, 1,               // 10456:      decode to VMLShq using decoder 247
                                             // 10456:     }
                                             // 10456:     } // switch Inst[21:20]
                                             // 10456:    }
  14, 59,                                    // 10461:    case 0xe: {
  OPC_SwitchField, 20, 2,                    // 10463:     switch Inst[21:20] {
  0, 12,                                     // 10466:     case 0x0: {
  OPC_CheckPredicate, 35,                    // 10468:      check predicate 35
  OPC_CheckField, 24, 8, 243, 1,             // 10470:      check Inst[31:24] == 0xf3
  OPC_Decode, 234, 16, 239, 1,               // 10475:      decode to VACGEfq using decoder 239
                                             // 10475:     }
  1, 12,                                     // 10480:     case 0x1: {
  OPC_CheckPredicate, 36,                    // 10482:      check predicate 36
  OPC_CheckField, 24, 8, 243, 1,             // 10484:      check Inst[31:24] == 0xf3
  OPC_Decode, 236, 16, 239, 1,               // 10489:      decode to VACGEhq using decoder 239
                                             // 10489:     }
  2, 12,                                     // 10494:     case 0x2: {
  OPC_CheckPredicate, 35,                    // 10496:      check predicate 35
  OPC_CheckField, 24, 8, 243, 1,             // 10498:      check Inst[31:24] == 0xf3
  OPC_Decode, 238, 16, 239, 1,               // 10503:      decode to VACGTfq using decoder 239
                                             // 10503:     }
  3, 0,                                      // 10508:     case 0x3: {
  OPC_CheckPredicate, 36,                    // 10510:      check predicate 36
  OPC_CheckField, 24, 8, 243, 1,             // 10512:      check Inst[31:24] == 0xf3
  OPC_Decode, 240, 16, 239, 1,               // 10517:      decode to VACGThq using decoder 239
                                             // 10517:     }
                                             // 10517:     } // switch Inst[21:20]
                                             // 10517:    }
  15, 0,                                     // 10522:    case 0xf: {
  OPC_SwitchField, 20, 2,                    // 10524:     switch Inst[21:20] {
  0, 12,                                     // 10527:     case 0x0: {
  OPC_CheckPredicate, 35,                    // 10529:      check predicate 35
  OPC_CheckField, 24, 8, 242, 1,             // 10531:      check Inst[31:24] == 0xf2
  OPC_Decode, 167, 26, 239, 1,               // 10536:      decode to VRECPSfq using decoder 239
                                             // 10536:     }
  1, 12,                                     // 10541:     case 0x1: {
  OPC_CheckPredicate, 36,                    // 10543:      check predicate 36
  OPC_CheckField, 24, 8, 242, 1,             // 10545:      check Inst[31:24] == 0xf2
  OPC_Decode, 169, 26, 239, 1,               // 10550:      decode to VRECPShq using decoder 239
                                             // 10550:     }
  2, 12,                                     // 10555:     case 0x2: {
  OPC_CheckPredicate, 35,                    // 10557:      check predicate 35
  OPC_CheckField, 24, 8, 242, 1,             // 10559:      check Inst[31:24] == 0xf2
  OPC_Decode, 153, 27, 239, 1,               // 10564:      decode to VRSQRTSfq using decoder 239
                                             // 10564:     }
  3, 0,                                      // 10569:     case 0x3: {
  OPC_CheckPredicate, 36,                    // 10571:      check predicate 36
  OPC_CheckField, 24, 8, 242, 1,             // 10573:      check Inst[31:24] == 0xf2
  OPC_Decode, 155, 27, 239, 1,               // 10578:      decode to VRSQRTShq using decoder 239
                                             // 10578:     }
                                             // 10578:     } // switch Inst[21:20]
                                             // 10578:    }
                                             // 10578:    } // switch Inst[11:8]
                                             // 10578:   }
  1, 0,                                      // 10583:   case 0x1: {
  OPC_SwitchField, 7, 1,                     // 10585:    switch Inst[7] {
  0, 175, 8,                                 // 10588:    case 0x0: {
  OPC_CheckField, 25, 7, 121,                // 10591:     check Inst[31:25] == 0x79
  OPC_Scope, 177, 7,                         // 10595:     try {
  OPC_SwitchField, 8, 4,                     // 10598:      switch Inst[11:8] {
  0, 85,                                     // 10601:      case 0x0: {
  OPC_SwitchField, 21, 1,                    // 10603:       switch Inst[21] {
  0, 57,                                     // 10606:       case 0x0: {
  OPC_SwitchField, 20, 1,                    // 10608:        switch Inst[20] {
  0, 29,                                     // 10611:        case 0x0: {
  OPC_SwitchField, 24, 1,                    // 10613:         switch Inst[24] {
  0, 11,                                     // 10616:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 10618:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 10620:          check Inst[19] == 0x1
  OPC_Decode, 232, 27, 180, 2,               // 10624:          decode to VSHRsv16i8 using decoder 308
                                             // 10624:         }
  1, 0,                                      // 10629:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 10631:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 10633:          check Inst[19] == 0x1
  OPC_Decode, 240, 27, 180, 2,               // 10637:          decode to VSHRuv16i8 using decoder 308
                                             // 10637:         }
                                             // 10637:         } // switch Inst[24]
                                             // 10637:        }
  1, 0,                                      // 10642:        case 0x1: {
  OPC_SwitchField, 24, 1,                    // 10644:         switch Inst[24] {
  0, 7,                                      // 10647:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 10649:          check predicate 35
  OPC_Decode, 238, 27, 181, 2,               // 10651:          decode to VSHRsv8i16 using decoder 309
                                             // 10651:         }
  1, 0,                                      // 10656:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 10658:          check predicate 35
  OPC_Decode, 246, 27, 181, 2,               // 10660:          decode to VSHRuv8i16 using decoder 309
                                             // 10660:         }
                                             // 10660:         } // switch Inst[24]
                                             // 10660:        }
                                             // 10660:        } // switch Inst[20]
                                             // 10660:       }
  1, 0,                                      // 10665:       case 0x1: {
  OPC_SwitchField, 24, 1,                    // 10667:        switch Inst[24] {
  0, 7,                                      // 10670:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 10672:         check predicate 35
  OPC_Decode, 237, 27, 182, 2,               // 10674:         decode to VSHRsv4i32 using decoder 310
                                             // 10674:        }
  1, 0,                                      // 10679:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 10681:         check predicate 35
  OPC_Decode, 245, 27, 182, 2,               // 10683:         decode to VSHRuv4i32 using decoder 310
                                             // 10683:        }
                                             // 10683:        } // switch Inst[24]
                                             // 10683:       }
                                             // 10683:       } // switch Inst[21]
                                             // 10683:      }
  1, 85,                                     // 10688:      case 0x1: {
  OPC_SwitchField, 21, 1,                    // 10690:       switch Inst[21] {
  0, 57,                                     // 10693:       case 0x0: {
  OPC_SwitchField, 20, 1,                    // 10695:        switch Inst[20] {
  0, 29,                                     // 10698:        case 0x0: {
  OPC_SwitchField, 24, 1,                    // 10700:         switch Inst[24] {
  0, 11,                                     // 10703:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 10705:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 10707:          check Inst[19] == 0x1
  OPC_Decode, 141, 28, 183, 2,               // 10711:          decode to VSRAsv16i8 using decoder 311
                                             // 10711:         }
  1, 0,                                      // 10716:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 10718:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 10720:          check Inst[19] == 0x1
  OPC_Decode, 149, 28, 183, 2,               // 10724:          decode to VSRAuv16i8 using decoder 311
                                             // 10724:         }
                                             // 10724:         } // switch Inst[24]
                                             // 10724:        }
  1, 0,                                      // 10729:        case 0x1: {
  OPC_SwitchField, 24, 1,                    // 10731:         switch Inst[24] {
  0, 7,                                      // 10734:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 10736:          check predicate 35
  OPC_Decode, 147, 28, 184, 2,               // 10738:          decode to VSRAsv8i16 using decoder 312
                                             // 10738:         }
  1, 0,                                      // 10743:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 10745:          check predicate 35
  OPC_Decode, 155, 28, 184, 2,               // 10747:          decode to VSRAuv8i16 using decoder 312
                                             // 10747:         }
                                             // 10747:         } // switch Inst[24]
                                             // 10747:        }
                                             // 10747:        } // switch Inst[20]
                                             // 10747:       }
  1, 0,                                      // 10752:       case 0x1: {
  OPC_SwitchField, 24, 1,                    // 10754:        switch Inst[24] {
  0, 7,                                      // 10757:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 10759:         check predicate 35
  OPC_Decode, 146, 28, 185, 2,               // 10761:         decode to VSRAsv4i32 using decoder 313
                                             // 10761:        }
  1, 0,                                      // 10766:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 10768:         check predicate 35
  OPC_Decode, 154, 28, 185, 2,               // 10770:         decode to VSRAuv4i32 using decoder 313
                                             // 10770:        }
                                             // 10770:        } // switch Inst[24]
                                             // 10770:       }
                                             // 10770:       } // switch Inst[21]
                                             // 10770:      }
  2, 85,                                     // 10775:      case 0x2: {
  OPC_SwitchField, 21, 1,                    // 10777:       switch Inst[21] {
  0, 57,                                     // 10780:       case 0x0: {
  OPC_SwitchField, 20, 1,                    // 10782:        switch Inst[20] {
  0, 29,                                     // 10785:        case 0x0: {
  OPC_SwitchField, 24, 1,                    // 10787:         switch Inst[24] {
  0, 11,                                     // 10790:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 10792:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 10794:          check Inst[19] == 0x1
  OPC_Decode, 130, 27, 180, 2,               // 10798:          decode to VRSHRsv16i8 using decoder 308
                                             // 10798:         }
  1, 0,                                      // 10803:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 10805:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 10807:          check Inst[19] == 0x1
  OPC_Decode, 138, 27, 180, 2,               // 10811:          decode to VRSHRuv16i8 using decoder 308
                                             // 10811:         }
                                             // 10811:         } // switch Inst[24]
                                             // 10811:        }
  1, 0,                                      // 10816:        case 0x1: {
  OPC_SwitchField, 24, 1,                    // 10818:         switch Inst[24] {
  0, 7,                                      // 10821:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 10823:          check predicate 35
  OPC_Decode, 136, 27, 181, 2,               // 10825:          decode to VRSHRsv8i16 using decoder 309
                                             // 10825:         }
  1, 0,                                      // 10830:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 10832:          check predicate 35
  OPC_Decode, 144, 27, 181, 2,               // 10834:          decode to VRSHRuv8i16 using decoder 309
                                             // 10834:         }
                                             // 10834:         } // switch Inst[24]
                                             // 10834:        }
                                             // 10834:        } // switch Inst[20]
                                             // 10834:       }
  1, 0,                                      // 10839:       case 0x1: {
  OPC_SwitchField, 24, 1,                    // 10841:        switch Inst[24] {
  0, 7,                                      // 10844:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 10846:         check predicate 35
  OPC_Decode, 135, 27, 182, 2,               // 10848:         decode to VRSHRsv4i32 using decoder 310
                                             // 10848:        }
  1, 0,                                      // 10853:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 10855:         check predicate 35
  OPC_Decode, 143, 27, 182, 2,               // 10857:         decode to VRSHRuv4i32 using decoder 310
                                             // 10857:        }
                                             // 10857:        } // switch Inst[24]
                                             // 10857:       }
                                             // 10857:       } // switch Inst[21]
                                             // 10857:      }
  3, 85,                                     // 10862:      case 0x3: {
  OPC_SwitchField, 21, 1,                    // 10864:       switch Inst[21] {
  0, 57,                                     // 10867:       case 0x0: {
  OPC_SwitchField, 20, 1,                    // 10869:        switch Inst[20] {
  0, 29,                                     // 10872:        case 0x0: {
  OPC_SwitchField, 24, 1,                    // 10874:         switch Inst[24] {
  0, 11,                                     // 10877:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 10879:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 10881:          check Inst[19] == 0x1
  OPC_Decode, 156, 27, 183, 2,               // 10885:          decode to VRSRAsv16i8 using decoder 311
                                             // 10885:         }
  1, 0,                                      // 10890:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 10892:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 10894:          check Inst[19] == 0x1
  OPC_Decode, 164, 27, 183, 2,               // 10898:          decode to VRSRAuv16i8 using decoder 311
                                             // 10898:         }
                                             // 10898:         } // switch Inst[24]
                                             // 10898:        }
  1, 0,                                      // 10903:        case 0x1: {
  OPC_SwitchField, 24, 1,                    // 10905:         switch Inst[24] {
  0, 7,                                      // 10908:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 10910:          check predicate 35
  OPC_Decode, 162, 27, 184, 2,               // 10912:          decode to VRSRAsv8i16 using decoder 312
                                             // 10912:         }
  1, 0,                                      // 10917:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 10919:          check predicate 35
  OPC_Decode, 170, 27, 184, 2,               // 10921:          decode to VRSRAuv8i16 using decoder 312
                                             // 10921:         }
                                             // 10921:         } // switch Inst[24]
                                             // 10921:        }
                                             // 10921:        } // switch Inst[20]
                                             // 10921:       }
  1, 0,                                      // 10926:       case 0x1: {
  OPC_SwitchField, 24, 1,                    // 10928:        switch Inst[24] {
  0, 7,                                      // 10931:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 10933:         check predicate 35
  OPC_Decode, 161, 27, 185, 2,               // 10935:         decode to VRSRAsv4i32 using decoder 313
                                             // 10935:        }
  1, 0,                                      // 10940:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 10942:         check predicate 35
  OPC_Decode, 169, 27, 185, 2,               // 10944:         decode to VRSRAuv4i32 using decoder 313
                                             // 10944:        }
                                             // 10944:        } // switch Inst[24]
                                             // 10944:       }
                                             // 10944:       } // switch Inst[21]
                                             // 10944:      }
  4, 51,                                     // 10949:      case 0x4: {
  OPC_SwitchField, 21, 1,                    // 10951:       switch Inst[21] {
  0, 33,                                     // 10954:       case 0x0: {
  OPC_SwitchField, 20, 1,                    // 10956:        switch Inst[20] {
  0, 15,                                     // 10959:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 10961:         check predicate 35
  OPC_CheckField, 24, 1, 1,                  // 10963:         check Inst[24] == 0x1
  OPC_CheckField, 19, 1, 1,                  // 10967:         check Inst[19] == 0x1
  OPC_Decode, 157, 28, 183, 2,               // 10971:         decode to VSRIv16i8 using decoder 311
                                             // 10971:        }
  1, 0,                                      // 10976:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 10978:         check predicate 35
  OPC_CheckField, 24, 1, 1,                  // 10980:         check Inst[24] == 0x1
  OPC_Decode, 163, 28, 184, 2,               // 10984:         decode to VSRIv8i16 using decoder 312
                                             // 10984:        }
                                             // 10984:        } // switch Inst[20]
                                             // 10984:       }
  1, 0,                                      // 10989:       case 0x1: {
  OPC_CheckPredicate, 35,                    // 10991:        check predicate 35
  OPC_CheckField, 24, 1, 1,                  // 10993:        check Inst[24] == 0x1
  OPC_Decode, 162, 28, 185, 2,               // 10997:        decode to VSRIv4i32 using decoder 313
                                             // 10997:       }
                                             // 10997:       } // switch Inst[21]
                                             // 10997:      }
  5, 85,                                     // 11002:      case 0x5: {
  OPC_SwitchField, 21, 1,                    // 11004:       switch Inst[21] {
  0, 57,                                     // 11007:       case 0x0: {
  OPC_SwitchField, 20, 1,                    // 11009:        switch Inst[20] {
  0, 29,                                     // 11012:        case 0x0: {
  OPC_SwitchField, 24, 1,                    // 11014:         switch Inst[24] {
  0, 11,                                     // 11017:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 11019:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 11021:          check Inst[19] == 0x1
  OPC_Decode, 205, 27, 186, 2,               // 11025:          decode to VSHLiv16i8 using decoder 314
                                             // 11025:         }
  1, 0,                                      // 11030:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 11032:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 11034:          check Inst[19] == 0x1
  OPC_Decode, 254, 27, 187, 2,               // 11038:          decode to VSLIv16i8 using decoder 315
                                             // 11038:         }
                                             // 11038:         } // switch Inst[24]
                                             // 11038:        }
  1, 0,                                      // 11043:        case 0x1: {
  OPC_SwitchField, 24, 1,                    // 11045:         switch Inst[24] {
  0, 7,                                      // 11048:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 11050:          check predicate 35
  OPC_Decode, 211, 27, 188, 2,               // 11052:          decode to VSHLiv8i16 using decoder 316
                                             // 11052:         }
  1, 0,                                      // 11057:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 11059:          check predicate 35
  OPC_Decode, 132, 28, 189, 2,               // 11061:          decode to VSLIv8i16 using decoder 317
                                             // 11061:         }
                                             // 11061:         } // switch Inst[24]
                                             // 11061:        }
                                             // 11061:        } // switch Inst[20]
                                             // 11061:       }
  1, 0,                                      // 11066:       case 0x1: {
  OPC_SwitchField, 24, 1,                    // 11068:        switch Inst[24] {
  0, 7,                                      // 11071:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 11073:         check predicate 35
  OPC_Decode, 210, 27, 190, 2,               // 11075:         decode to VSHLiv4i32 using decoder 318
                                             // 11075:        }
  1, 0,                                      // 11080:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 11082:         check predicate 35
  OPC_Decode, 131, 28, 191, 2,               // 11084:         decode to VSLIv4i32 using decoder 319
                                             // 11084:        }
                                             // 11084:        } // switch Inst[24]
                                             // 11084:       }
                                             // 11084:       } // switch Inst[21]
                                             // 11084:      }
  6, 51,                                     // 11089:      case 0x6: {
  OPC_SwitchField, 21, 1,                    // 11091:       switch Inst[21] {
  0, 33,                                     // 11094:       case 0x0: {
  OPC_SwitchField, 20, 1,                    // 11096:        switch Inst[20] {
  0, 15,                                     // 11099:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 11101:         check predicate 35
  OPC_CheckField, 24, 1, 1,                  // 11103:         check Inst[24] == 0x1
  OPC_CheckField, 19, 1, 1,                  // 11107:         check Inst[19] == 0x1
  OPC_Decode, 228, 25, 186, 2,               // 11111:         decode to VQSHLsuv16i8 using decoder 314
                                             // 11111:        }
  1, 0,                                      // 11116:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 11118:         check predicate 35
  OPC_CheckField, 24, 1, 1,                  // 11120:         check Inst[24] == 0x1
  OPC_Decode, 234, 25, 188, 2,               // 11124:         decode to VQSHLsuv8i16 using decoder 316
                                             // 11124:        }
                                             // 11124:        } // switch Inst[20]
                                             // 11124:       }
  1, 0,                                      // 11129:       case 0x1: {
  OPC_CheckPredicate, 35,                    // 11131:        check predicate 35
  OPC_CheckField, 24, 1, 1,                  // 11133:        check Inst[24] == 0x1
  OPC_Decode, 233, 25, 190, 2,               // 11137:        decode to VQSHLsuv4i32 using decoder 318
                                             // 11137:       }
                                             // 11137:       } // switch Inst[21]
                                             // 11137:      }
  7, 85,                                     // 11142:      case 0x7: {
  OPC_SwitchField, 21, 1,                    // 11144:       switch Inst[21] {
  0, 57,                                     // 11147:       case 0x0: {
  OPC_SwitchField, 20, 1,                    // 11149:        switch Inst[20] {
  0, 29,                                     // 11152:        case 0x0: {
  OPC_SwitchField, 24, 1,                    // 11154:         switch Inst[24] {
  0, 11,                                     // 11157:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 11159:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 11161:          check Inst[19] == 0x1
  OPC_Decode, 220, 25, 186, 2,               // 11165:          decode to VQSHLsiv16i8 using decoder 314
                                             // 11165:         }
  1, 0,                                      // 11170:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 11172:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 11174:          check Inst[19] == 0x1
  OPC_Decode, 244, 25, 186, 2,               // 11178:          decode to VQSHLuiv16i8 using decoder 314
                                             // 11178:         }
                                             // 11178:         } // switch Inst[24]
                                             // 11178:        }
  1, 0,                                      // 11183:        case 0x1: {
  OPC_SwitchField, 24, 1,                    // 11185:         switch Inst[24] {
  0, 7,                                      // 11188:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 11190:          check predicate 35
  OPC_Decode, 226, 25, 188, 2,               // 11192:          decode to VQSHLsiv8i16 using decoder 316
                                             // 11192:         }
  1, 0,                                      // 11197:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 11199:          check predicate 35
  OPC_Decode, 250, 25, 188, 2,               // 11201:          decode to VQSHLuiv8i16 using decoder 316
                                             // 11201:         }
                                             // 11201:         } // switch Inst[24]
                                             // 11201:        }
                                             // 11201:        } // switch Inst[20]
                                             // 11201:       }
  1, 0,                                      // 11206:       case 0x1: {
  OPC_SwitchField, 24, 1,                    // 11208:        switch Inst[24] {
  0, 7,                                      // 11211:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 11213:         check predicate 35
  OPC_Decode, 225, 25, 190, 2,               // 11215:         decode to VQSHLsiv4i32 using decoder 318
                                             // 11215:        }
  1, 0,                                      // 11220:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 11222:         check predicate 35
  OPC_Decode, 249, 25, 190, 2,               // 11224:         decode to VQSHLuiv4i32 using decoder 318
                                             // 11224:        }
                                             // 11224:        } // switch Inst[24]
                                             // 11224:       }
                                             // 11224:       } // switch Inst[21]
                                             // 11224:      }
  8, 85,                                     // 11229:      case 0x8: {
  OPC_SwitchField, 21, 1,                    // 11231:       switch Inst[21] {
  0, 57,                                     // 11234:       case 0x0: {
  OPC_SwitchField, 20, 1,                    // 11236:        switch Inst[20] {
  0, 29,                                     // 11239:        case 0x0: {
  OPC_SwitchField, 24, 1,                    // 11241:         switch Inst[24] {
  0, 11,                                     // 11244:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 11246:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 11248:          check Inst[19] == 0x1
  OPC_Decode, 129, 27, 168, 2,               // 11252:          decode to VRSHRNv8i8 using decoder 296
                                             // 11252:         }
  1, 0,                                      // 11257:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 11259:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 11261:          check Inst[19] == 0x1
  OPC_Decode, 219, 25, 168, 2,               // 11265:          decode to VQRSHRUNv8i8 using decoder 296
                                             // 11265:         }
                                             // 11265:         } // switch Inst[24]
                                             // 11265:        }
  1, 0,                                      // 11270:        case 0x1: {
  OPC_SwitchField, 24, 1,                    // 11272:         switch Inst[24] {
  0, 7,                                      // 11275:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 11277:          check predicate 35
  OPC_Decode, 128, 27, 169, 2,               // 11279:          decode to VRSHRNv4i16 using decoder 297
                                             // 11279:         }
  1, 0,                                      // 11284:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 11286:          check predicate 35
  OPC_Decode, 218, 25, 169, 2,               // 11288:          decode to VQRSHRUNv4i16 using decoder 297
                                             // 11288:         }
                                             // 11288:         } // switch Inst[24]
                                             // 11288:        }
                                             // 11288:        } // switch Inst[20]
                                             // 11288:       }
  1, 0,                                      // 11293:       case 0x1: {
  OPC_SwitchField, 24, 1,                    // 11295:        switch Inst[24] {
  0, 7,                                      // 11298:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 11300:         check predicate 35
  OPC_Decode, 255, 26, 170, 2,               // 11302:         decode to VRSHRNv2i32 using decoder 298
                                             // 11302:        }
  1, 0,                                      // 11307:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 11309:         check predicate 35
  OPC_Decode, 217, 25, 170, 2,               // 11311:         decode to VQRSHRUNv2i32 using decoder 298
                                             // 11311:        }
                                             // 11311:        } // switch Inst[24]
                                             // 11311:       }
                                             // 11311:       } // switch Inst[21]
                                             // 11311:      }
  9, 85,                                     // 11316:      case 0x9: {
  OPC_SwitchField, 21, 1,                    // 11318:       switch Inst[21] {
  0, 57,                                     // 11321:       case 0x0: {
  OPC_SwitchField, 20, 1,                    // 11323:        switch Inst[20] {
  0, 29,                                     // 11326:        case 0x0: {
  OPC_SwitchField, 24, 1,                    // 11328:         switch Inst[24] {
  0, 11,                                     // 11331:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 11333:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 11335:          check Inst[19] == 0x1
  OPC_Decode, 213, 25, 168, 2,               // 11339:          decode to VQRSHRNsv8i8 using decoder 296
                                             // 11339:         }
  1, 0,                                      // 11344:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 11346:          check predicate 35
  OPC_CheckField, 19, 1, 1,                  // 11348:          check Inst[19] == 0x1
  OPC_Decode, 216, 25, 168, 2,               // 11352:          decode to VQRSHRNuv8i8 using decoder 296
                                             // 11352:         }
                                             // 11352:         } // switch Inst[24]
                                             // 11352:        }
  1, 0,                                      // 11357:        case 0x1: {
  OPC_SwitchField, 24, 1,                    // 11359:         switch Inst[24] {
  0, 7,                                      // 11362:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 11364:          check predicate 35
  OPC_Decode, 212, 25, 169, 2,               // 11366:          decode to VQRSHRNsv4i16 using decoder 297
                                             // 11366:         }
  1, 0,                                      // 11371:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 11373:          check predicate 35
  OPC_Decode, 215, 25, 169, 2,               // 11375:          decode to VQRSHRNuv4i16 using decoder 297
                                             // 11375:         }
                                             // 11375:         } // switch Inst[24]
                                             // 11375:        }
                                             // 11375:        } // switch Inst[20]
                                             // 11375:       }
  1, 0,                                      // 11380:       case 0x1: {
  OPC_SwitchField, 24, 1,                    // 11382:        switch Inst[24] {
  0, 7,                                      // 11385:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 11387:         check predicate 35
  OPC_Decode, 211, 25, 170, 2,               // 11389:         decode to VQRSHRNsv2i32 using decoder 298
                                             // 11389:        }
  1, 0,                                      // 11394:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 11396:         check predicate 35
  OPC_Decode, 214, 25, 170, 2,               // 11398:         decode to VQRSHRNuv2i32 using decoder 298
                                             // 11398:        }
                                             // 11398:        } // switch Inst[24]
                                             // 11398:       }
                                             // 11398:       } // switch Inst[21]
                                             // 11398:      }
  12, 21,                                    // 11403:      case 0xc: {
  OPC_SwitchField, 24, 1,                    // 11405:       switch Inst[24] {
  0, 7,                                      // 11408:       case 0x0: {
  OPC_CheckPredicate, 36,                    // 11410:        check predicate 36
  OPC_Decode, 132, 19, 192, 2,               // 11412:        decode to VCVTxs2hq using decoder 320
                                             // 11412:       }
  1, 0,                                      // 11417:       case 0x1: {
  OPC_CheckPredicate, 36,                    // 11419:        check predicate 36
  OPC_Decode, 136, 19, 192, 2,               // 11421:        decode to VCVTxu2hq using decoder 320
                                             // 11421:       }
                                             // 11421:       } // switch Inst[24]
                                             // 11421:      }
  13, 21,                                    // 11426:      case 0xd: {
  OPC_SwitchField, 24, 1,                    // 11428:       switch Inst[24] {
  0, 7,                                      // 11431:       case 0x0: {
  OPC_CheckPredicate, 36,                    // 11433:        check predicate 36
  OPC_Decode, 246, 18, 192, 2,               // 11435:        decode to VCVTh2xsq using decoder 320
                                             // 11435:       }
  1, 0,                                      // 11440:       case 0x1: {
  OPC_CheckPredicate, 36,                    // 11442:        check predicate 36
  OPC_Decode, 248, 18, 192, 2,               // 11444:        decode to VCVTh2xuq using decoder 320
                                             // 11444:       }
                                             // 11444:       } // switch Inst[24]
                                             // 11444:      }
  14, 52,                                    // 11449:      case 0xe: {
  OPC_Scope, 29,                             // 11451:       try {
  OPC_SwitchField, 5, 1,                     // 11453:        switch Inst[5] {
  0, 11,                                     // 11456:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 11458:         check predicate 35
  OPC_CheckField, 19, 3, 0,                  // 11460:         check Inst[21:19] == 0x0
  OPC_Decode, 221, 23, 175, 2,               // 11464:         decode to VMOVv16i8 using decoder 303
                                             // 11464:        }
  1, 0,                                      // 11469:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 11471:         check predicate 35
  OPC_CheckField, 19, 3, 0,                  // 11473:         check Inst[21:19] == 0x0
  OPC_Decode, 225, 23, 175, 2,               // 11477:         decode to VMOVv2i64 using decoder 303
                                             // 11477:        }
                                             // 11477:        } // switch Inst[5]
                                             // 11477:       } else try {
  OPC_SwitchField, 24, 1,                    // 11482:        switch Inst[24] {
  0, 7,                                      // 11485:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 11487:         check predicate 35
  OPC_Decode, 130, 19, 192, 2,               // 11489:         decode to VCVTxs2fq using decoder 320
                                             // 11489:        }
  1, 0,                                      // 11494:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 11496:         check predicate 35
  OPC_Decode, 134, 19, 192, 2,               // 11498:         decode to VCVTxu2fq using decoder 320
                                             // 11498:        }
                                             // 11498:        } // switch Inst[24]
                                             // 11498:       }
                                             // 11498:      }
  15, 0,                                     // 11503:      case 0xf: {
  OPC_Scope, 21,                             // 11505:       try {
  OPC_SwitchField, 24, 1,                    // 11507:        switch Inst[24] {
  0, 7,                                      // 11510:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 11512:         check predicate 35
  OPC_Decode, 237, 18, 192, 2,               // 11514:         decode to VCVTf2xsq using decoder 320
                                             // 11514:        }
  1, 0,                                      // 11519:        case 0x1: {
  OPC_CheckPredicate, 35,                    // 11521:         check predicate 35
  OPC_Decode, 239, 18, 192, 2,               // 11523:         decode to VCVTf2xuq using decoder 320
                                             // 11523:        }
                                             // 11523:        } // switch Inst[24]
                                             // 11523:       } else try {
  OPC_CheckPredicate, 35,                    // 11528:        check predicate 35
  OPC_CheckField, 19, 3, 0,                  // 11530:        check Inst[21:19] == 0x0
  OPC_CheckField, 5, 1, 0,                   // 11534:        check Inst[5] == 0x0
  OPC_Decode, 226, 23, 175, 2,               // 11538:        decode to VMOVv4f32 using decoder 303
                                             // 11538:       }
                                             // 11538:      }
                                             // 11538:      } // switch Inst[11:8]
                                             // 11538:     } else try {
  OPC_SwitchField, 5, 1,                     // 11543:      switch Inst[5] {
  0, 56,                                     // 11546:      case 0x0: {
  OPC_CheckField, 19, 3, 0,                  // 11548:       check Inst[21:19] == 0x0
  OPC_Scope, 43,                             // 11552:       try {
  OPC_SwitchField, 8, 1,                     // 11554:        switch Inst[8] {
  0, 11,                                     // 11557:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 11559:         check predicate 35
  OPC_CheckField, 10, 2, 2,                  // 11561:         check Inst[11:10] == 0x2
  OPC_Decode, 229, 23, 175, 2,               // 11565:         decode to VMOVv8i16 using decoder 303
                                             // 11565:        }
  1, 0,                                      // 11570:        case 0x1: {
  OPC_SwitchField, 11, 1,                    // 11572:         switch Inst[11] {
  0, 7,                                      // 11575:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 11577:          check predicate 35
  OPC_Decode, 194, 24, 175, 2,               // 11579:          decode to VORRiv4i32 using decoder 303
                                             // 11579:         }
  1, 0,                                      // 11584:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 11586:          check predicate 35
  OPC_CheckField, 10, 1, 0,                  // 11588:          check Inst[10] == 0x0
  OPC_Decode, 195, 24, 175, 2,               // 11592:          decode to VORRiv8i16 using decoder 303
                                             // 11592:         }
                                             // 11592:         } // switch Inst[11]
                                             // 11592:        }
                                             // 11592:        } // switch Inst[8]
                                             // 11592:       } else try {
  OPC_CheckPredicate, 35,                    // 11597:        check predicate 35
  OPC_Decode, 228, 23, 175, 2,               // 11599:        decode to VMOVv4i32 using decoder 303
                                             // 11599:       }
                                             // 11599:      }
  1, 0,                                      // 11604:      case 0x1: {
  OPC_CheckField, 19, 3, 0,                  // 11606:       check Inst[21:19] == 0x0
  OPC_Scope, 43,                             // 11610:       try {
  OPC_SwitchField, 8, 1,                     // 11612:        switch Inst[8] {
  0, 11,                                     // 11615:        case 0x0: {
  OPC_CheckPredicate, 35,                    // 11617:         check predicate 35
  OPC_CheckField, 10, 2, 2,                  // 11619:         check Inst[11:10] == 0x2
  OPC_Decode, 166, 24, 175, 2,               // 11623:         decode to VMVNv8i16 using decoder 303
                                             // 11623:        }
  1, 0,                                      // 11628:        case 0x1: {
  OPC_SwitchField, 11, 1,                    // 11630:         switch Inst[11] {
  0, 7,                                      // 11633:         case 0x0: {
  OPC_CheckPredicate, 35,                    // 11635:          check predicate 35
  OPC_Decode, 152, 17, 175, 2,               // 11637:          decode to VBICiv4i32 using decoder 303
                                             // 11637:         }
  1, 0,                                      // 11642:         case 0x1: {
  OPC_CheckPredicate, 35,                    // 11644:          check predicate 35
  OPC_CheckField, 10, 1, 0,                  // 11646:          check Inst[10] == 0x0
  OPC_Decode, 153, 17, 175, 2,               // 11650:          decode to VBICiv8i16 using decoder 303
                                             // 11650:         }
                                             // 11650:         } // switch Inst[11]
                                             // 11650:        }
                                             // 11650:        } // switch Inst[8]
                                             // 11650:       } else try {
  OPC_CheckPredicate, 35,                    // 11655:        check predicate 35
  OPC_Decode, 165, 24, 175, 2,               // 11657:        decode to VMVNv4i32 using decoder 303
                                             // 11657:       }
                                             // 11657:      }
                                             // 11657:      } // switch Inst[5]
                                             // 11657:     }
                                             // 11657:    }
  1, 0,                                      // 11662:    case 0x1: {
  OPC_SwitchField, 8, 4,                     // 11664:     switch Inst[11:8] {
  0, 23,                                     // 11667:     case 0x0: {
  OPC_SwitchField, 24, 8,                    // 11669:      switch Inst[31:24] {
  242, 1, 7,                                 // 11672:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 11675:       check predicate 35
  OPC_Decode, 235, 27, 193, 2,               // 11677:       decode to VSHRsv2i64 using decoder 321
                                             // 11677:      }
  243, 1, 0,                                 // 11682:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 11685:       check predicate 35
  OPC_Decode, 243, 27, 193, 2,               // 11687:       decode to VSHRuv2i64 using decoder 321
                                             // 11687:      }
                                             // 11687:      } // switch Inst[31:24]
                                             // 11687:     }
  1, 23,                                     // 11692:     case 0x1: {
  OPC_SwitchField, 24, 8,                    // 11694:      switch Inst[31:24] {
  242, 1, 7,                                 // 11697:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 11700:       check predicate 35
  OPC_Decode, 144, 28, 194, 2,               // 11702:       decode to VSRAsv2i64 using decoder 322
                                             // 11702:      }
  243, 1, 0,                                 // 11707:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 11710:       check predicate 35
  OPC_Decode, 152, 28, 194, 2,               // 11712:       decode to VSRAuv2i64 using decoder 322
                                             // 11712:      }
                                             // 11712:      } // switch Inst[31:24]
                                             // 11712:     }
  2, 23,                                     // 11717:     case 0x2: {
  OPC_SwitchField, 24, 8,                    // 11719:      switch Inst[31:24] {
  242, 1, 7,                                 // 11722:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 11725:       check predicate 35
  OPC_Decode, 133, 27, 193, 2,               // 11727:       decode to VRSHRsv2i64 using decoder 321
                                             // 11727:      }
  243, 1, 0,                                 // 11732:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 11735:       check predicate 35
  OPC_Decode, 141, 27, 193, 2,               // 11737:       decode to VRSHRuv2i64 using decoder 321
                                             // 11737:      }
                                             // 11737:      } // switch Inst[31:24]
                                             // 11737:     }
  3, 23,                                     // 11742:     case 0x3: {
  OPC_SwitchField, 24, 8,                    // 11744:      switch Inst[31:24] {
  242, 1, 7,                                 // 11747:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 11750:       check predicate 35
  OPC_Decode, 159, 27, 194, 2,               // 11752:       decode to VRSRAsv2i64 using decoder 322
                                             // 11752:      }
  243, 1, 0,                                 // 11757:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 11760:       check predicate 35
  OPC_Decode, 167, 27, 194, 2,               // 11762:       decode to VRSRAuv2i64 using decoder 322
                                             // 11762:      }
                                             // 11762:      } // switch Inst[31:24]
                                             // 11762:     }
  4, 12,                                     // 11767:     case 0x4: {
  OPC_CheckPredicate, 35,                    // 11769:      check predicate 35
  OPC_CheckField, 24, 8, 243, 1,             // 11771:      check Inst[31:24] == 0xf3
  OPC_Decode, 160, 28, 194, 2,               // 11776:      decode to VSRIv2i64 using decoder 322
                                             // 11776:     }
  5, 23,                                     // 11781:     case 0x5: {
  OPC_SwitchField, 24, 8,                    // 11783:      switch Inst[31:24] {
  242, 1, 7,                                 // 11786:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 11789:       check predicate 35
  OPC_Decode, 208, 27, 195, 2,               // 11791:       decode to VSHLiv2i64 using decoder 323
                                             // 11791:      }
  243, 1, 0,                                 // 11796:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 11799:       check predicate 35
  OPC_Decode, 129, 28, 196, 2,               // 11801:       decode to VSLIv2i64 using decoder 324
                                             // 11801:      }
                                             // 11801:      } // switch Inst[31:24]
                                             // 11801:     }
  6, 12,                                     // 11806:     case 0x6: {
  OPC_CheckPredicate, 35,                    // 11808:      check predicate 35
  OPC_CheckField, 24, 8, 243, 1,             // 11810:      check Inst[31:24] == 0xf3
  OPC_Decode, 231, 25, 195, 2,               // 11815:      decode to VQSHLsuv2i64 using decoder 323
                                             // 11815:     }
  7, 0,                                      // 11820:     case 0x7: {
  OPC_SwitchField, 24, 8,                    // 11822:      switch Inst[31:24] {
  242, 1, 7,                                 // 11825:      case 0xf2: {
  OPC_CheckPredicate, 35,                    // 11828:       check predicate 35
  OPC_Decode, 223, 25, 195, 2,               // 11830:       decode to VQSHLsiv2i64 using decoder 323
                                             // 11830:      }
  243, 1, 0,                                 // 11835:      case 0xf3: {
  OPC_CheckPredicate, 35,                    // 11838:       check predicate 35
  OPC_Decode, 247, 25, 195, 2,               // 11840:       decode to VQSHLuiv2i64 using decoder 323
                                             // 11840:      }
                                             // 11840:      } // switch Inst[31:24]
                                             // 11840:     }
                                             // 11840:     } // switch Inst[11:8]
                                             // 11840:    }
                                             // 11840:    } // switch Inst[7]
                                             // 11840:   }
                                             // 11840:   } // switch Inst[23]
                                             // 11840:  }
                                             // 11840:  } // switch Inst[6]
                                             // 11840: }
                                             // 11840: } // switch Inst[4]
};
static const uint8_t DecoderTableNEONDup32[279] = {
  OPC_SwitchField, 22, 6,                    //   0: switch Inst[27:22] {
  56, 73,                                    //   3: case 0x38: {
  OPC_SwitchField, 0, 6,                     //   5:  switch Inst[5:0] {
  16, 37,                                    //   8:  case 0x10: {
  OPC_SwitchField, 20, 1,                    //  10:   switch Inst[20] {
  0, 15,                                     //  13:   case 0x0: {
  OPC_CheckPredicate, 42,                    //  15:    check predicate 42
  OPC_CheckField, 8, 4, 11,                  //  17:    check Inst[11:8] == 0xb
  OPC_CheckField, 6, 1, 0,                   //  21:    check Inst[6] == 0x0
  OPC_Decode, 194, 27, 197, 2,               //  25:    decode to VSETLNi32 using decoder 325
                                             //  25:   }
  1, 0,                                      //  30:   case 0x1: {
  OPC_CheckPredicate, 43,                    //  32:    check predicate 43
  OPC_CheckField, 8, 4, 11,                  //  34:    check Inst[11:8] == 0xb
  OPC_CheckField, 6, 1, 0,                   //  38:    check Inst[6] == 0x0
  OPC_Decode, 195, 19, 198, 2,               //  42:    decode to VGETLNi32 using decoder 326
                                             //  42:   }
                                             //  42:   } // switch Inst[20]
                                             //  42:  }
  48, 0,                                     //  47:  case 0x30: {
  OPC_SwitchField, 20, 1,                    //  49:   switch Inst[20] {
  0, 11,                                     //  52:   case 0x0: {
  OPC_CheckPredicate, 35,                    //  54:    check predicate 35
  OPC_CheckField, 8, 4, 11,                  //  56:    check Inst[11:8] == 0xb
  OPC_Decode, 193, 27, 199, 2,               //  60:    decode to VSETLNi16 using decoder 327
                                             //  60:   }
  1, 0,                                      //  65:   case 0x1: {
  OPC_CheckPredicate, 35,                    //  67:    check predicate 35
  OPC_CheckField, 8, 4, 11,                  //  69:    check Inst[11:8] == 0xb
  OPC_Decode, 196, 19, 200, 2,               //  73:    decode to VGETLNs16 using decoder 328
                                             //  73:   }
                                             //  73:   } // switch Inst[20]
                                             //  73:  }
                                             //  73:  } // switch Inst[5:0]
                                             //  73: }
  57, 37,                                    //  78: case 0x39: {
  OPC_SwitchField, 20, 1,                    //  80:  switch Inst[20] {
  0, 15,                                     //  83:  case 0x0: {
  OPC_CheckPredicate, 35,                    //  85:   check predicate 35
  OPC_CheckField, 8, 4, 11,                  //  87:   check Inst[11:8] == 0xb
  OPC_CheckField, 0, 5, 16,                  //  91:   check Inst[4:0] == 0x10
  OPC_Decode, 195, 27, 201, 2,               //  95:   decode to VSETLNi8 using decoder 329
                                             //  95:  }
  1, 0,                                      // 100:  case 0x1: {
  OPC_CheckPredicate, 35,                    // 102:   check predicate 35
  OPC_CheckField, 8, 4, 11,                  // 104:   check Inst[11:8] == 0xb
  OPC_CheckField, 0, 5, 16,                  // 108:   check Inst[4:0] == 0x10
  OPC_Decode, 197, 19, 202, 2,               // 112:   decode to VGETLNs8 using decoder 330
                                             // 112:  }
                                             // 112:  } // switch Inst[20]
                                             // 112: }
  58, 99,                                    // 117: case 0x3a: {
  OPC_SwitchField, 0, 6,                     // 119:  switch Inst[5:0] {
  16, 37,                                    // 122:  case 0x10: {
  OPC_SwitchField, 20, 2,                    // 124:   switch Inst[21:20] {
  0, 15,                                     // 127:   case 0x0: {
  OPC_CheckPredicate, 35,                    // 129:    check predicate 35
  OPC_CheckField, 8, 4, 11,                  // 131:    check Inst[11:8] == 0xb
  OPC_CheckField, 6, 1, 0,                   // 135:    check Inst[6] == 0x0
  OPC_Decode, 142, 19, 203, 2,               // 139:    decode to VDUP32d using decoder 331
                                             // 139:   }
  2, 0,                                      // 144:   case 0x2: {
  OPC_CheckPredicate, 35,                    // 146:    check predicate 35
  OPC_CheckField, 8, 4, 11,                  // 148:    check Inst[11:8] == 0xb
  OPC_CheckField, 6, 1, 0,                   // 152:    check Inst[6] == 0x0
  OPC_Decode, 143, 19, 204, 2,               // 156:    decode to VDUP32q using decoder 332
                                             // 156:   }
                                             // 156:   } // switch Inst[21:20]
                                             // 156:  }
  48, 0,                                     // 161:  case 0x30: {
  OPC_SwitchField, 20, 1,                    // 163:   switch Inst[20] {
  0, 37,                                     // 166:   case 0x0: {
  OPC_SwitchField, 21, 1,                    // 168:    switch Inst[21] {
  0, 15,                                     // 171:    case 0x0: {
  OPC_CheckPredicate, 35,                    // 173:     check predicate 35
  OPC_CheckField, 8, 4, 11,                  // 175:     check Inst[11:8] == 0xb
  OPC_CheckField, 6, 1, 0,                   // 179:     check Inst[6] == 0x0
  OPC_Decode, 140, 19, 203, 2,               // 183:     decode to VDUP16d using decoder 331
                                             // 183:    }
  1, 0,                                      // 188:    case 0x1: {
  OPC_CheckPredicate, 35,                    // 190:     check predicate 35
  OPC_CheckField, 8, 4, 11,                  // 192:     check Inst[11:8] == 0xb
  OPC_CheckField, 6, 1, 0,                   // 196:     check Inst[6] == 0x0
  OPC_Decode, 141, 19, 204, 2,               // 200:     decode to VDUP16q using decoder 332
                                             // 200:    }
                                             // 200:    } // switch Inst[21]
                                             // 200:   }
  1, 0,                                      // 205:   case 0x1: {
  OPC_CheckPredicate, 35,                    // 207:    check predicate 35
  OPC_CheckField, 8, 4, 11,                  // 209:    check Inst[11:8] == 0xb
  OPC_Decode, 198, 19, 200, 2,               // 213:    decode to VGETLNu16 using decoder 328
                                             // 213:   }
                                             // 213:   } // switch Inst[20]
                                             // 213:  }
                                             // 213:  } // switch Inst[5:0]
                                             // 213: }
  59, 0,                                     // 218: case 0x3b: {
  OPC_SwitchField, 20, 1,                    // 220:  switch Inst[20] {
  0, 37,                                     // 223:  case 0x0: {
  OPC_SwitchField, 21, 1,                    // 225:   switch Inst[21] {
  0, 15,                                     // 228:   case 0x0: {
  OPC_CheckPredicate, 35,                    // 230:    check predicate 35
  OPC_CheckField, 8, 4, 11,                  // 232:    check Inst[11:8] == 0xb
  OPC_CheckField, 0, 7, 16,                  // 236:    check Inst[6:0] == 0x10
  OPC_Decode, 144, 19, 203, 2,               // 240:    decode to VDUP8d using decoder 331
                                             // 240:   }
  1, 0,                                      // 245:   case 0x1: {
  OPC_CheckPredicate, 35,                    // 247:    check predicate 35
  OPC_CheckField, 8, 4, 11,                  // 249:    check Inst[11:8] == 0xb
  OPC_CheckField, 0, 7, 16,                  // 253:    check Inst[6:0] == 0x10
  OPC_Decode, 145, 19, 204, 2,               // 257:    decode to VDUP8q using decoder 332
                                             // 257:   }
                                             // 257:   } // switch Inst[21]
                                             // 257:  }
  1, 0,                                      // 262:  case 0x1: {
  OPC_CheckPredicate, 35,                    // 264:   check predicate 35
  OPC_CheckField, 8, 4, 11,                  // 266:   check Inst[11:8] == 0xb
  OPC_CheckField, 0, 5, 16,                  // 270:   check Inst[4:0] == 0x10
  OPC_Decode, 199, 19, 202, 2,               // 274:   decode to VGETLNu8 using decoder 330
                                             // 274:  }
                                             // 274:  } // switch Inst[20]
                                             // 274: }
                                             // 274: } // switch Inst[27:22]
};
static const uint8_t DecoderTableNEONLoadStore32[4440] = {
  OPC_SwitchField, 8, 4,                     //    0: switch Inst[11:8] {
  0, 211, 1,                                 //    3: case 0x0: {
  OPC_SwitchField, 20, 2,                    //    6:  switch Inst[21:20] {
  0, 102,                                    //    9:  case 0x0: {
  OPC_SwitchField, 23, 9,                    //   11:   switch Inst[31:23] {
  232, 3, 69,                                //   14:   case 0x1e8: {
  OPC_SwitchField, 6, 2,                     //   17:    switch Inst[7:6] {
  0, 20,                                     //   20:    case 0x0: {
  OPC_Scope, 11,                             //   22:     try {
  OPC_CheckField, 0, 4, 15,                  //   24:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //   28:      check predicate 35
  OPC_Decode, 148, 30, 205, 2,               //   30:      decode to VST4d8 using decoder 333
                                             //   30:     } else try {
  OPC_CheckPredicate, 35,                    //   35:      check predicate 35
  OPC_Decode, 151, 30, 205, 2,               //   37:      decode to VST4d8_UPD using decoder 333
                                             //   37:     }
                                             //   37:    }
  1, 20,                                     //   42:    case 0x1: {
  OPC_Scope, 11,                             //   44:     try {
  OPC_CheckField, 0, 4, 15,                  //   46:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //   50:      check predicate 35
  OPC_Decode, 140, 30, 205, 2,               //   52:      decode to VST4d16 using decoder 333
                                             //   52:     } else try {
  OPC_CheckPredicate, 35,                    //   57:      check predicate 35
  OPC_Decode, 143, 30, 205, 2,               //   59:      decode to VST4d16_UPD using decoder 333
                                             //   59:     }
                                             //   59:    }
  2, 0,                                      //   64:    case 0x2: {
  OPC_Scope, 11,                             //   66:     try {
  OPC_CheckField, 0, 4, 15,                  //   68:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //   72:      check predicate 35
  OPC_Decode, 144, 30, 205, 2,               //   74:      decode to VST4d32 using decoder 333
                                             //   74:     } else try {
  OPC_CheckPredicate, 35,                    //   79:      check predicate 35
  OPC_Decode, 147, 30, 205, 2,               //   81:      decode to VST4d32_UPD using decoder 333
                                             //   81:     }
                                             //   81:    }
                                             //   81:    } // switch Inst[7:6]
                                             //   81:   }
  233, 3, 0,                                 //   86:   case 0x1e9: {
  OPC_CheckField, 4, 1, 0,                   //   89:    check Inst[4] == 0x0
  OPC_Scope, 11,                             //   93:    try {
  OPC_CheckField, 0, 4, 15,                  //   95:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //   99:     check predicate 35
  OPC_Decode, 169, 28, 206, 2,               //  101:     decode to VST1LNd8 using decoder 334
                                             //  101:    } else try {
  OPC_CheckPredicate, 35,                    //  106:     check predicate 35
  OPC_Decode, 170, 28, 206, 2,               //  108:     decode to VST1LNd8_UPD using decoder 334
                                             //  108:    }
                                             //  108:   }
                                             //  108:   } // switch Inst[31:23]
                                             //  108:  }
  2, 0,                                      //  113:  case 0x2: {
  OPC_SwitchField, 23, 9,                    //  115:   switch Inst[31:23] {
  232, 3, 69,                                //  118:   case 0x1e8: {
  OPC_SwitchField, 6, 2,                     //  121:    switch Inst[7:6] {
  0, 20,                                     //  124:    case 0x0: {
  OPC_Scope, 11,                             //  126:     try {
  OPC_CheckField, 0, 4, 15,                  //  128:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  132:      check predicate 35
  OPC_Decode, 183, 22, 205, 2,               //  134:      decode to VLD4d8 using decoder 333
                                             //  134:     } else try {
  OPC_CheckPredicate, 35,                    //  139:      check predicate 35
  OPC_Decode, 186, 22, 205, 2,               //  141:      decode to VLD4d8_UPD using decoder 333
                                             //  141:     }
                                             //  141:    }
  1, 20,                                     //  146:    case 0x1: {
  OPC_Scope, 11,                             //  148:     try {
  OPC_CheckField, 0, 4, 15,                  //  150:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  154:      check predicate 35
  OPC_Decode, 175, 22, 205, 2,               //  156:      decode to VLD4d16 using decoder 333
                                             //  156:     } else try {
  OPC_CheckPredicate, 35,                    //  161:      check predicate 35
  OPC_Decode, 178, 22, 205, 2,               //  163:      decode to VLD4d16_UPD using decoder 333
                                             //  163:     }
                                             //  163:    }
  2, 0,                                      //  168:    case 0x2: {
  OPC_Scope, 11,                             //  170:     try {
  OPC_CheckField, 0, 4, 15,                  //  172:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  176:      check predicate 35
  OPC_Decode, 179, 22, 205, 2,               //  178:      decode to VLD4d32 using decoder 333
                                             //  178:     } else try {
  OPC_CheckPredicate, 35,                    //  183:      check predicate 35
  OPC_Decode, 182, 22, 205, 2,               //  185:      decode to VLD4d32_UPD using decoder 333
                                             //  185:     }
                                             //  185:    }
                                             //  185:    } // switch Inst[7:6]
                                             //  185:   }
  233, 3, 0,                                 //  190:   case 0x1e9: {
  OPC_CheckField, 4, 1, 0,                   //  193:    check Inst[4] == 0x0
  OPC_Scope, 11,                             //  197:    try {
  OPC_CheckField, 0, 4, 15,                  //  199:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  203:     check predicate 35
  OPC_Decode, 248, 19, 207, 2,               //  205:     decode to VLD1LNd8 using decoder 335
                                             //  205:    } else try {
  OPC_CheckPredicate, 35,                    //  210:     check predicate 35
  OPC_Decode, 249, 19, 207, 2,               //  212:     decode to VLD1LNd8_UPD using decoder 335
                                             //  212:    }
                                             //  212:   }
                                             //  212:   } // switch Inst[31:23]
                                             //  212:  }
                                             //  212:  } // switch Inst[21:20]
                                             //  212: }
  1, 203, 1,                                 //  217: case 0x1: {
  OPC_SwitchField, 20, 2,                    //  220:  switch Inst[21:20] {
  0, 98,                                     //  223:  case 0x0: {
  OPC_SwitchField, 23, 9,                    //  225:   switch Inst[31:23] {
  232, 3, 69,                                //  228:   case 0x1e8: {
  OPC_SwitchField, 6, 2,                     //  231:    switch Inst[7:6] {
  0, 20,                                     //  234:    case 0x0: {
  OPC_Scope, 11,                             //  236:     try {
  OPC_CheckField, 0, 4, 15,                  //  238:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  242:      check predicate 35
  OPC_Decode, 162, 30, 205, 2,               //  244:      decode to VST4q8 using decoder 333
                                             //  244:     } else try {
  OPC_CheckPredicate, 35,                    //  249:      check predicate 35
  OPC_Decode, 164, 30, 205, 2,               //  251:      decode to VST4q8_UPD using decoder 333
                                             //  251:     }
                                             //  251:    }
  1, 20,                                     //  256:    case 0x1: {
  OPC_Scope, 11,                             //  258:     try {
  OPC_CheckField, 0, 4, 15,                  //  260:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  264:      check predicate 35
  OPC_Decode, 152, 30, 205, 2,               //  266:      decode to VST4q16 using decoder 333
                                             //  266:     } else try {
  OPC_CheckPredicate, 35,                    //  271:      check predicate 35
  OPC_Decode, 154, 30, 205, 2,               //  273:      decode to VST4q16_UPD using decoder 333
                                             //  273:     }
                                             //  273:    }
  2, 0,                                      //  278:    case 0x2: {
  OPC_Scope, 11,                             //  280:     try {
  OPC_CheckField, 0, 4, 15,                  //  282:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  286:      check predicate 35
  OPC_Decode, 157, 30, 205, 2,               //  288:      decode to VST4q32 using decoder 333
                                             //  288:     } else try {
  OPC_CheckPredicate, 35,                    //  293:      check predicate 35
  OPC_Decode, 159, 30, 205, 2,               //  295:      decode to VST4q32_UPD using decoder 333
                                             //  295:     }
                                             //  295:    }
                                             //  295:    } // switch Inst[7:6]
                                             //  295:   }
  233, 3, 0,                                 //  300:   case 0x1e9: {
  OPC_Scope, 11,                             //  303:    try {
  OPC_CheckField, 0, 4, 15,                  //  305:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  309:     check predicate 35
  OPC_Decode, 153, 29, 208, 2,               //  311:     decode to VST2LNd8 using decoder 336
                                             //  311:    } else try {
  OPC_CheckPredicate, 35,                    //  316:     check predicate 35
  OPC_Decode, 156, 29, 208, 2,               //  318:     decode to VST2LNd8_UPD using decoder 336
                                             //  318:    }
                                             //  318:   }
                                             //  318:   } // switch Inst[31:23]
                                             //  318:  }
  2, 0,                                      //  323:  case 0x2: {
  OPC_SwitchField, 23, 9,                    //  325:   switch Inst[31:23] {
  232, 3, 69,                                //  328:   case 0x1e8: {
  OPC_SwitchField, 6, 2,                     //  331:    switch Inst[7:6] {
  0, 20,                                     //  334:    case 0x0: {
  OPC_Scope, 11,                             //  336:     try {
  OPC_CheckField, 0, 4, 15,                  //  338:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  342:      check predicate 35
  OPC_Decode, 197, 22, 205, 2,               //  344:      decode to VLD4q8 using decoder 333
                                             //  344:     } else try {
  OPC_CheckPredicate, 35,                    //  349:      check predicate 35
  OPC_Decode, 199, 22, 205, 2,               //  351:      decode to VLD4q8_UPD using decoder 333
                                             //  351:     }
                                             //  351:    }
  1, 20,                                     //  356:    case 0x1: {
  OPC_Scope, 11,                             //  358:     try {
  OPC_CheckField, 0, 4, 15,                  //  360:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  364:      check predicate 35
  OPC_Decode, 187, 22, 205, 2,               //  366:      decode to VLD4q16 using decoder 333
                                             //  366:     } else try {
  OPC_CheckPredicate, 35,                    //  371:      check predicate 35
  OPC_Decode, 189, 22, 205, 2,               //  373:      decode to VLD4q16_UPD using decoder 333
                                             //  373:     }
                                             //  373:    }
  2, 0,                                      //  378:    case 0x2: {
  OPC_Scope, 11,                             //  380:     try {
  OPC_CheckField, 0, 4, 15,                  //  382:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  386:      check predicate 35
  OPC_Decode, 192, 22, 205, 2,               //  388:      decode to VLD4q32 using decoder 333
                                             //  388:     } else try {
  OPC_CheckPredicate, 35,                    //  393:      check predicate 35
  OPC_Decode, 194, 22, 205, 2,               //  395:      decode to VLD4q32_UPD using decoder 333
                                             //  395:     }
                                             //  395:    }
                                             //  395:    } // switch Inst[7:6]
                                             //  395:   }
  233, 3, 0,                                 //  400:   case 0x1e9: {
  OPC_Scope, 11,                             //  403:    try {
  OPC_CheckField, 0, 4, 15,                  //  405:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  409:     check predicate 35
  OPC_Decode, 134, 21, 209, 2,               //  411:     decode to VLD2LNd8 using decoder 337
                                             //  411:    } else try {
  OPC_CheckPredicate, 35,                    //  416:     check predicate 35
  OPC_Decode, 137, 21, 209, 2,               //  418:     decode to VLD2LNd8_UPD using decoder 337
                                             //  418:    }
                                             //  418:   }
                                             //  418:   } // switch Inst[31:23]
                                             //  418:  }
                                             //  418:  } // switch Inst[21:20]
                                             //  418: }
  2, 210, 2,                                 //  423: case 0x2: {
  OPC_SwitchField, 20, 2,                    //  426:  switch Inst[21:20] {
  0, 165, 1,                                 //  429:  case 0x0: {
  OPC_SwitchField, 23, 9,                    //  432:   switch Inst[31:23] {
  232, 3, 131, 1,                            //  435:   case 0x1e8: {
  OPC_SwitchField, 6, 2,                     //  439:    switch Inst[7:6] {
  0, 30,                                     //  442:    case 0x0: {
  OPC_Scope, 21,                             //  444:     try {
  OPC_SwitchField, 0, 4,                     //  446:      switch Inst[3:0] {
  13, 7,                                     //  449:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  451:       check predicate 35
  OPC_Decode, 227, 28, 210, 2,               //  453:       decode to VST1d8Qwb_fixed using decoder 338
                                             //  453:      }
  15, 0,                                     //  458:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  460:       check predicate 35
  OPC_Decode, 223, 28, 210, 2,               //  462:       decode to VST1d8Q using decoder 338
                                             //  462:      }
                                             //  462:      } // switch Inst[3:0]
                                             //  462:     } else try {
  OPC_CheckPredicate, 35,                    //  467:      check predicate 35
  OPC_Decode, 228, 28, 210, 2,               //  469:      decode to VST1d8Qwb_register using decoder 338
                                             //  469:     }
                                             //  469:    }
  1, 30,                                     //  474:    case 0x1: {
  OPC_Scope, 21,                             //  476:     try {
  OPC_SwitchField, 0, 4,                     //  478:      switch Inst[3:0] {
  13, 7,                                     //  481:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  483:       check predicate 35
  OPC_Decode, 182, 28, 210, 2,               //  485:       decode to VST1d16Qwb_fixed using decoder 338
                                             //  485:      }
  15, 0,                                     //  490:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  492:       check predicate 35
  OPC_Decode, 178, 28, 210, 2,               //  494:       decode to VST1d16Q using decoder 338
                                             //  494:      }
                                             //  494:      } // switch Inst[3:0]
                                             //  494:     } else try {
  OPC_CheckPredicate, 35,                    //  499:      check predicate 35
  OPC_Decode, 183, 28, 210, 2,               //  501:      decode to VST1d16Qwb_register using decoder 338
                                             //  501:     }
                                             //  501:    }
  2, 30,                                     //  506:    case 0x2: {
  OPC_Scope, 21,                             //  508:     try {
  OPC_SwitchField, 0, 4,                     //  510:      switch Inst[3:0] {
  13, 7,                                     //  513:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  515:       check predicate 35
  OPC_Decode, 197, 28, 210, 2,               //  517:       decode to VST1d32Qwb_fixed using decoder 338
                                             //  517:      }
  15, 0,                                     //  522:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  524:       check predicate 35
  OPC_Decode, 193, 28, 210, 2,               //  526:       decode to VST1d32Q using decoder 338
                                             //  526:      }
                                             //  526:      } // switch Inst[3:0]
                                             //  526:     } else try {
  OPC_CheckPredicate, 35,                    //  531:      check predicate 35
  OPC_Decode, 198, 28, 210, 2,               //  533:      decode to VST1d32Qwb_register using decoder 338
                                             //  533:     }
                                             //  533:    }
  3, 0,                                      //  538:    case 0x3: {
  OPC_Scope, 21,                             //  540:     try {
  OPC_SwitchField, 0, 4,                     //  542:      switch Inst[3:0] {
  13, 7,                                     //  545:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  547:       check predicate 35
  OPC_Decode, 212, 28, 210, 2,               //  549:       decode to VST1d64Qwb_fixed using decoder 338
                                             //  549:      }
  15, 0,                                     //  554:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  556:       check predicate 35
  OPC_Decode, 208, 28, 210, 2,               //  558:       decode to VST1d64Q using decoder 338
                                             //  558:      }
                                             //  558:      } // switch Inst[3:0]
                                             //  558:     } else try {
  OPC_CheckPredicate, 35,                    //  563:      check predicate 35
  OPC_Decode, 213, 28, 210, 2,               //  565:      decode to VST1d64Qwb_register using decoder 338
                                             //  565:     }
                                             //  565:    }
                                             //  565:    } // switch Inst[7:6]
                                             //  565:   }
  233, 3, 0,                                 //  570:   case 0x1e9: {
  OPC_CheckField, 4, 1, 0,                   //  573:    check Inst[4] == 0x0
  OPC_Scope, 11,                             //  577:    try {
  OPC_CheckField, 0, 4, 15,                  //  579:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  583:     check predicate 35
  OPC_Decode, 209, 29, 211, 2,               //  585:     decode to VST3LNd8 using decoder 339
                                             //  585:    } else try {
  OPC_CheckPredicate, 35,                    //  590:     check predicate 35
  OPC_Decode, 212, 29, 211, 2,               //  592:     decode to VST3LNd8_UPD using decoder 339
                                             //  592:    }
                                             //  592:   }
                                             //  592:   } // switch Inst[31:23]
                                             //  592:  }
  2, 0,                                      //  597:  case 0x2: {
  OPC_SwitchField, 23, 9,                    //  599:   switch Inst[31:23] {
  232, 3, 131, 1,                            //  602:   case 0x1e8: {
  OPC_SwitchField, 6, 2,                     //  606:    switch Inst[7:6] {
  0, 30,                                     //  609:    case 0x0: {
  OPC_Scope, 21,                             //  611:     try {
  OPC_SwitchField, 0, 4,                     //  613:      switch Inst[3:0] {
  13, 7,                                     //  616:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  618:       check predicate 35
  OPC_Decode, 178, 20, 210, 2,               //  620:       decode to VLD1d8Qwb_fixed using decoder 338
                                             //  620:      }
  15, 0,                                     //  625:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  627:       check predicate 35
  OPC_Decode, 174, 20, 210, 2,               //  629:       decode to VLD1d8Q using decoder 338
                                             //  629:      }
                                             //  629:      } // switch Inst[3:0]
                                             //  629:     } else try {
  OPC_CheckPredicate, 35,                    //  634:      check predicate 35
  OPC_Decode, 179, 20, 210, 2,               //  636:      decode to VLD1d8Qwb_register using decoder 338
                                             //  636:     }
                                             //  636:    }
  1, 30,                                     //  641:    case 0x1: {
  OPC_Scope, 21,                             //  643:     try {
  OPC_SwitchField, 0, 4,                     //  645:      switch Inst[3:0] {
  13, 7,                                     //  648:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  650:       check predicate 35
  OPC_Decode, 133, 20, 210, 2,               //  652:       decode to VLD1d16Qwb_fixed using decoder 338
                                             //  652:      }
  15, 0,                                     //  657:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  659:       check predicate 35
  OPC_Decode, 129, 20, 210, 2,               //  661:       decode to VLD1d16Q using decoder 338
                                             //  661:      }
                                             //  661:      } // switch Inst[3:0]
                                             //  661:     } else try {
  OPC_CheckPredicate, 35,                    //  666:      check predicate 35
  OPC_Decode, 134, 20, 210, 2,               //  668:      decode to VLD1d16Qwb_register using decoder 338
                                             //  668:     }
                                             //  668:    }
  2, 30,                                     //  673:    case 0x2: {
  OPC_Scope, 21,                             //  675:     try {
  OPC_SwitchField, 0, 4,                     //  677:      switch Inst[3:0] {
  13, 7,                                     //  680:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  682:       check predicate 35
  OPC_Decode, 148, 20, 210, 2,               //  684:       decode to VLD1d32Qwb_fixed using decoder 338
                                             //  684:      }
  15, 0,                                     //  689:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  691:       check predicate 35
  OPC_Decode, 144, 20, 210, 2,               //  693:       decode to VLD1d32Q using decoder 338
                                             //  693:      }
                                             //  693:      } // switch Inst[3:0]
                                             //  693:     } else try {
  OPC_CheckPredicate, 35,                    //  698:      check predicate 35
  OPC_Decode, 149, 20, 210, 2,               //  700:      decode to VLD1d32Qwb_register using decoder 338
                                             //  700:     }
                                             //  700:    }
  3, 0,                                      //  705:    case 0x3: {
  OPC_Scope, 21,                             //  707:     try {
  OPC_SwitchField, 0, 4,                     //  709:      switch Inst[3:0] {
  13, 7,                                     //  712:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  714:       check predicate 35
  OPC_Decode, 163, 20, 210, 2,               //  716:       decode to VLD1d64Qwb_fixed using decoder 338
                                             //  716:      }
  15, 0,                                     //  721:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  723:       check predicate 35
  OPC_Decode, 159, 20, 210, 2,               //  725:       decode to VLD1d64Q using decoder 338
                                             //  725:      }
                                             //  725:      } // switch Inst[3:0]
                                             //  725:     } else try {
  OPC_CheckPredicate, 35,                    //  730:      check predicate 35
  OPC_Decode, 164, 20, 210, 2,               //  732:      decode to VLD1d64Qwb_register using decoder 338
                                             //  732:     }
                                             //  732:    }
                                             //  732:    } // switch Inst[7:6]
                                             //  732:   }
  233, 3, 0,                                 //  737:   case 0x1e9: {
  OPC_CheckField, 4, 1, 0,                   //  740:    check Inst[4] == 0x0
  OPC_Scope, 11,                             //  744:    try {
  OPC_CheckField, 0, 4, 15,                  //  746:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  750:     check predicate 35
  OPC_Decode, 217, 21, 212, 2,               //  752:     decode to VLD3LNd8 using decoder 340
                                             //  752:    } else try {
  OPC_CheckPredicate, 35,                    //  757:     check predicate 35
  OPC_Decode, 220, 21, 212, 2,               //  759:     decode to VLD3LNd8_UPD using decoder 340
                                             //  759:    }
                                             //  759:   }
                                             //  759:   } // switch Inst[31:23]
                                             //  759:  }
                                             //  759:  } // switch Inst[21:20]
                                             //  759: }
  3, 136, 2,                                 //  764: case 0x3: {
  OPC_SwitchField, 20, 2,                    //  767:  switch Inst[21:20] {
  0, 128, 1,                                 //  770:  case 0x0: {
  OPC_SwitchField, 23, 9,                    //  773:   switch Inst[31:23] {
  232, 3, 99,                                //  776:   case 0x1e8: {
  OPC_SwitchField, 6, 2,                     //  779:    switch Inst[7:6] {
  0, 30,                                     //  782:    case 0x0: {
  OPC_Scope, 21,                             //  784:     try {
  OPC_SwitchField, 0, 4,                     //  786:      switch Inst[3:0] {
  13, 7,                                     //  789:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  791:       check predicate 35
  OPC_Decode, 199, 29, 213, 2,               //  793:       decode to VST2q8wb_fixed using decoder 341
                                             //  793:      }
  15, 0,                                     //  798:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  800:       check predicate 35
  OPC_Decode, 195, 29, 213, 2,               //  802:       decode to VST2q8 using decoder 341
                                             //  802:      }
                                             //  802:      } // switch Inst[3:0]
                                             //  802:     } else try {
  OPC_CheckPredicate, 35,                    //  807:      check predicate 35
  OPC_Decode, 200, 29, 213, 2,               //  809:      decode to VST2q8wb_register using decoder 341
                                             //  809:     }
                                             //  809:    }
  1, 30,                                     //  814:    case 0x1: {
  OPC_Scope, 21,                             //  816:     try {
  OPC_SwitchField, 0, 4,                     //  818:      switch Inst[3:0] {
  13, 7,                                     //  821:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  823:       check predicate 35
  OPC_Decode, 187, 29, 213, 2,               //  825:       decode to VST2q16wb_fixed using decoder 341
                                             //  825:      }
  15, 0,                                     //  830:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  832:       check predicate 35
  OPC_Decode, 183, 29, 213, 2,               //  834:       decode to VST2q16 using decoder 341
                                             //  834:      }
                                             //  834:      } // switch Inst[3:0]
                                             //  834:     } else try {
  OPC_CheckPredicate, 35,                    //  839:      check predicate 35
  OPC_Decode, 188, 29, 213, 2,               //  841:      decode to VST2q16wb_register using decoder 341
                                             //  841:     }
                                             //  841:    }
  2, 0,                                      //  846:    case 0x2: {
  OPC_Scope, 21,                             //  848:     try {
  OPC_SwitchField, 0, 4,                     //  850:      switch Inst[3:0] {
  13, 7,                                     //  853:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  855:       check predicate 35
  OPC_Decode, 193, 29, 213, 2,               //  857:       decode to VST2q32wb_fixed using decoder 341
                                             //  857:      }
  15, 0,                                     //  862:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  864:       check predicate 35
  OPC_Decode, 189, 29, 213, 2,               //  866:       decode to VST2q32 using decoder 341
                                             //  866:      }
                                             //  866:      } // switch Inst[3:0]
                                             //  866:     } else try {
  OPC_CheckPredicate, 35,                    //  871:      check predicate 35
  OPC_Decode, 194, 29, 213, 2,               //  873:      decode to VST2q32wb_register using decoder 341
                                             //  873:     }
                                             //  873:    }
                                             //  873:    } // switch Inst[7:6]
                                             //  873:   }
  233, 3, 0,                                 //  878:   case 0x1e9: {
  OPC_Scope, 11,                             //  881:    try {
  OPC_CheckField, 0, 4, 15,                  //  883:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    //  887:     check predicate 35
  OPC_Decode, 128, 30, 214, 2,               //  889:     decode to VST4LNd8 using decoder 342
                                             //  889:    } else try {
  OPC_CheckPredicate, 35,                    //  894:     check predicate 35
  OPC_Decode, 131, 30, 214, 2,               //  896:     decode to VST4LNd8_UPD using decoder 342
                                             //  896:    }
                                             //  896:   }
                                             //  896:   } // switch Inst[31:23]
                                             //  896:  }
  2, 0,                                      //  901:  case 0x2: {
  OPC_SwitchField, 23, 9,                    //  903:   switch Inst[31:23] {
  232, 3, 99,                                //  906:   case 0x1e8: {
  OPC_SwitchField, 6, 2,                     //  909:    switch Inst[7:6] {
  0, 30,                                     //  912:    case 0x0: {
  OPC_Scope, 21,                             //  914:     try {
  OPC_SwitchField, 0, 4,                     //  916:      switch Inst[3:0] {
  13, 7,                                     //  919:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  921:       check predicate 35
  OPC_Decode, 180, 21, 213, 2,               //  923:       decode to VLD2q8wb_fixed using decoder 341
                                             //  923:      }
  15, 0,                                     //  928:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  930:       check predicate 35
  OPC_Decode, 176, 21, 213, 2,               //  932:       decode to VLD2q8 using decoder 341
                                             //  932:      }
                                             //  932:      } // switch Inst[3:0]
                                             //  932:     } else try {
  OPC_CheckPredicate, 35,                    //  937:      check predicate 35
  OPC_Decode, 181, 21, 213, 2,               //  939:      decode to VLD2q8wb_register using decoder 341
                                             //  939:     }
                                             //  939:    }
  1, 30,                                     //  944:    case 0x1: {
  OPC_Scope, 21,                             //  946:     try {
  OPC_SwitchField, 0, 4,                     //  948:      switch Inst[3:0] {
  13, 7,                                     //  951:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  953:       check predicate 35
  OPC_Decode, 168, 21, 213, 2,               //  955:       decode to VLD2q16wb_fixed using decoder 341
                                             //  955:      }
  15, 0,                                     //  960:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  962:       check predicate 35
  OPC_Decode, 164, 21, 213, 2,               //  964:       decode to VLD2q16 using decoder 341
                                             //  964:      }
                                             //  964:      } // switch Inst[3:0]
                                             //  964:     } else try {
  OPC_CheckPredicate, 35,                    //  969:      check predicate 35
  OPC_Decode, 169, 21, 213, 2,               //  971:      decode to VLD2q16wb_register using decoder 341
                                             //  971:     }
                                             //  971:    }
  2, 0,                                      //  976:    case 0x2: {
  OPC_Scope, 21,                             //  978:     try {
  OPC_SwitchField, 0, 4,                     //  980:      switch Inst[3:0] {
  13, 7,                                     //  983:      case 0xd: {
  OPC_CheckPredicate, 35,                    //  985:       check predicate 35
  OPC_Decode, 174, 21, 213, 2,               //  987:       decode to VLD2q32wb_fixed using decoder 341
                                             //  987:      }
  15, 0,                                     //  992:      case 0xf: {
  OPC_CheckPredicate, 35,                    //  994:       check predicate 35
  OPC_Decode, 170, 21, 213, 2,               //  996:       decode to VLD2q32 using decoder 341
                                             //  996:      }
                                             //  996:      } // switch Inst[3:0]
                                             //  996:     } else try {
  OPC_CheckPredicate, 35,                    // 1001:      check predicate 35
  OPC_Decode, 175, 21, 213, 2,               // 1003:      decode to VLD2q32wb_register using decoder 341
                                             // 1003:     }
                                             // 1003:    }
                                             // 1003:    } // switch Inst[7:6]
                                             // 1003:   }
  233, 3, 0,                                 // 1008:   case 0x1e9: {
  OPC_Scope, 11,                             // 1011:    try {
  OPC_CheckField, 0, 4, 15,                  // 1013:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1017:     check predicate 35
  OPC_Decode, 163, 22, 215, 2,               // 1019:     decode to VLD4LNd8 using decoder 343
                                             // 1019:    } else try {
  OPC_CheckPredicate, 35,                    // 1024:     check predicate 35
  OPC_Decode, 166, 22, 215, 2,               // 1026:     decode to VLD4LNd8_UPD using decoder 343
                                             // 1026:    }
                                             // 1026:   }
                                             // 1026:   } // switch Inst[31:23]
                                             // 1026:  }
                                             // 1026:  } // switch Inst[21:20]
                                             // 1026: }
  4, 211, 1,                                 // 1031: case 0x4: {
  OPC_SwitchField, 20, 2,                    // 1034:  switch Inst[21:20] {
  0, 102,                                    // 1037:  case 0x0: {
  OPC_SwitchField, 23, 9,                    // 1039:   switch Inst[31:23] {
  232, 3, 69,                                // 1042:   case 0x1e8: {
  OPC_SwitchField, 5, 3,                     // 1045:    switch Inst[7:5] {
  0, 20,                                     // 1048:    case 0x0: {
  OPC_Scope, 11,                             // 1050:     try {
  OPC_CheckField, 0, 4, 15,                  // 1052:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1056:      check predicate 35
  OPC_Decode, 229, 29, 216, 2,               // 1058:      decode to VST3d8 using decoder 344
                                             // 1058:     } else try {
  OPC_CheckPredicate, 35,                    // 1063:      check predicate 35
  OPC_Decode, 232, 29, 216, 2,               // 1065:      decode to VST3d8_UPD using decoder 344
                                             // 1065:     }
                                             // 1065:    }
  2, 20,                                     // 1070:    case 0x2: {
  OPC_Scope, 11,                             // 1072:     try {
  OPC_CheckField, 0, 4, 15,                  // 1074:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1078:      check predicate 35
  OPC_Decode, 221, 29, 216, 2,               // 1080:      decode to VST3d16 using decoder 344
                                             // 1080:     } else try {
  OPC_CheckPredicate, 35,                    // 1085:      check predicate 35
  OPC_Decode, 224, 29, 216, 2,               // 1087:      decode to VST3d16_UPD using decoder 344
                                             // 1087:     }
                                             // 1087:    }
  4, 0,                                      // 1092:    case 0x4: {
  OPC_Scope, 11,                             // 1094:     try {
  OPC_CheckField, 0, 4, 15,                  // 1096:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1100:      check predicate 35
  OPC_Decode, 225, 29, 216, 2,               // 1102:      decode to VST3d32 using decoder 344
                                             // 1102:     } else try {
  OPC_CheckPredicate, 35,                    // 1107:      check predicate 35
  OPC_Decode, 228, 29, 216, 2,               // 1109:      decode to VST3d32_UPD using decoder 344
                                             // 1109:     }
                                             // 1109:    }
                                             // 1109:    } // switch Inst[7:5]
                                             // 1109:   }
  233, 3, 0,                                 // 1114:   case 0x1e9: {
  OPC_CheckField, 5, 1, 0,                   // 1117:    check Inst[5] == 0x0
  OPC_Scope, 11,                             // 1121:    try {
  OPC_CheckField, 0, 4, 15,                  // 1123:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1127:     check predicate 35
  OPC_Decode, 165, 28, 206, 2,               // 1129:     decode to VST1LNd16 using decoder 334
                                             // 1129:    } else try {
  OPC_CheckPredicate, 35,                    // 1134:     check predicate 35
  OPC_Decode, 166, 28, 206, 2,               // 1136:     decode to VST1LNd16_UPD using decoder 334
                                             // 1136:    }
                                             // 1136:   }
                                             // 1136:   } // switch Inst[31:23]
                                             // 1136:  }
  2, 0,                                      // 1141:  case 0x2: {
  OPC_SwitchField, 23, 9,                    // 1143:   switch Inst[31:23] {
  232, 3, 69,                                // 1146:   case 0x1e8: {
  OPC_SwitchField, 5, 3,                     // 1149:    switch Inst[7:5] {
  0, 20,                                     // 1152:    case 0x0: {
  OPC_Scope, 11,                             // 1154:     try {
  OPC_CheckField, 0, 4, 15,                  // 1156:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1160:      check predicate 35
  OPC_Decode, 237, 21, 216, 2,               // 1162:      decode to VLD3d8 using decoder 344
                                             // 1162:     } else try {
  OPC_CheckPredicate, 35,                    // 1167:      check predicate 35
  OPC_Decode, 240, 21, 216, 2,               // 1169:      decode to VLD3d8_UPD using decoder 344
                                             // 1169:     }
                                             // 1169:    }
  2, 20,                                     // 1174:    case 0x2: {
  OPC_Scope, 11,                             // 1176:     try {
  OPC_CheckField, 0, 4, 15,                  // 1178:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1182:      check predicate 35
  OPC_Decode, 229, 21, 216, 2,               // 1184:      decode to VLD3d16 using decoder 344
                                             // 1184:     } else try {
  OPC_CheckPredicate, 35,                    // 1189:      check predicate 35
  OPC_Decode, 232, 21, 216, 2,               // 1191:      decode to VLD3d16_UPD using decoder 344
                                             // 1191:     }
                                             // 1191:    }
  4, 0,                                      // 1196:    case 0x4: {
  OPC_Scope, 11,                             // 1198:     try {
  OPC_CheckField, 0, 4, 15,                  // 1200:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1204:      check predicate 35
  OPC_Decode, 233, 21, 216, 2,               // 1206:      decode to VLD3d32 using decoder 344
                                             // 1206:     } else try {
  OPC_CheckPredicate, 35,                    // 1211:      check predicate 35
  OPC_Decode, 236, 21, 216, 2,               // 1213:      decode to VLD3d32_UPD using decoder 344
                                             // 1213:     }
                                             // 1213:    }
                                             // 1213:    } // switch Inst[7:5]
                                             // 1213:   }
  233, 3, 0,                                 // 1218:   case 0x1e9: {
  OPC_Scope, 11,                             // 1221:    try {
  OPC_CheckField, 0, 4, 15,                  // 1223:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1227:     check predicate 35
  OPC_Decode, 244, 19, 207, 2,               // 1229:     decode to VLD1LNd16 using decoder 335
                                             // 1229:    } else try {
  OPC_CheckPredicate, 35,                    // 1234:     check predicate 35
  OPC_CheckField, 5, 1, 0,                   // 1236:     check Inst[5] == 0x0
  OPC_Decode, 245, 19, 207, 2,               // 1240:     decode to VLD1LNd16_UPD using decoder 335
                                             // 1240:    }
                                             // 1240:   }
                                             // 1240:   } // switch Inst[31:23]
                                             // 1240:  }
                                             // 1240:  } // switch Inst[21:20]
                                             // 1240: }
  5, 140, 2,                                 // 1245: case 0x5: {
  OPC_SwitchField, 5, 1,                     // 1248:  switch Inst[5] {
  0, 203, 1,                                 // 1251:  case 0x0: {
  OPC_SwitchField, 20, 2,                    // 1254:   switch Inst[21:20] {
  0, 98,                                     // 1257:   case 0x0: {
  OPC_SwitchField, 23, 9,                    // 1259:    switch Inst[31:23] {
  232, 3, 69,                                // 1262:    case 0x1e8: {
  OPC_SwitchField, 6, 2,                     // 1265:     switch Inst[7:6] {
  0, 20,                                     // 1268:     case 0x0: {
  OPC_Scope, 11,                             // 1270:      try {
  OPC_CheckField, 0, 4, 15,                  // 1272:       check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1276:       check predicate 35
  OPC_Decode, 243, 29, 216, 2,               // 1278:       decode to VST3q8 using decoder 344
                                             // 1278:      } else try {
  OPC_CheckPredicate, 35,                    // 1283:       check predicate 35
  OPC_Decode, 245, 29, 216, 2,               // 1285:       decode to VST3q8_UPD using decoder 344
                                             // 1285:      }
                                             // 1285:     }
  1, 20,                                     // 1290:     case 0x1: {
  OPC_Scope, 11,                             // 1292:      try {
  OPC_CheckField, 0, 4, 15,                  // 1294:       check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1298:       check predicate 35
  OPC_Decode, 233, 29, 216, 2,               // 1300:       decode to VST3q16 using decoder 344
                                             // 1300:      } else try {
  OPC_CheckPredicate, 35,                    // 1305:       check predicate 35
  OPC_Decode, 235, 29, 216, 2,               // 1307:       decode to VST3q16_UPD using decoder 344
                                             // 1307:      }
                                             // 1307:     }
  2, 0,                                      // 1312:     case 0x2: {
  OPC_Scope, 11,                             // 1314:      try {
  OPC_CheckField, 0, 4, 15,                  // 1316:       check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1320:       check predicate 35
  OPC_Decode, 238, 29, 216, 2,               // 1322:       decode to VST3q32 using decoder 344
                                             // 1322:      } else try {
  OPC_CheckPredicate, 35,                    // 1327:       check predicate 35
  OPC_Decode, 240, 29, 216, 2,               // 1329:       decode to VST3q32_UPD using decoder 344
                                             // 1329:      }
                                             // 1329:     }
                                             // 1329:     } // switch Inst[7:6]
                                             // 1329:    }
  233, 3, 0,                                 // 1334:    case 0x1e9: {
  OPC_Scope, 11,                             // 1337:     try {
  OPC_CheckField, 0, 4, 15,                  // 1339:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1343:      check predicate 35
  OPC_Decode, 145, 29, 208, 2,               // 1345:      decode to VST2LNd16 using decoder 336
                                             // 1345:     } else try {
  OPC_CheckPredicate, 35,                    // 1350:      check predicate 35
  OPC_Decode, 148, 29, 208, 2,               // 1352:      decode to VST2LNd16_UPD using decoder 336
                                             // 1352:     }
                                             // 1352:    }
                                             // 1352:    } // switch Inst[31:23]
                                             // 1352:   }
  2, 0,                                      // 1357:   case 0x2: {
  OPC_SwitchField, 23, 9,                    // 1359:    switch Inst[31:23] {
  232, 3, 69,                                // 1362:    case 0x1e8: {
  OPC_SwitchField, 6, 2,                     // 1365:     switch Inst[7:6] {
  0, 20,                                     // 1368:     case 0x0: {
  OPC_Scope, 11,                             // 1370:      try {
  OPC_CheckField, 0, 4, 15,                  // 1372:       check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1376:       check predicate 35
  OPC_Decode, 251, 21, 216, 2,               // 1378:       decode to VLD3q8 using decoder 344
                                             // 1378:      } else try {
  OPC_CheckPredicate, 35,                    // 1383:       check predicate 35
  OPC_Decode, 253, 21, 216, 2,               // 1385:       decode to VLD3q8_UPD using decoder 344
                                             // 1385:      }
                                             // 1385:     }
  1, 20,                                     // 1390:     case 0x1: {
  OPC_Scope, 11,                             // 1392:      try {
  OPC_CheckField, 0, 4, 15,                  // 1394:       check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1398:       check predicate 35
  OPC_Decode, 241, 21, 216, 2,               // 1400:       decode to VLD3q16 using decoder 344
                                             // 1400:      } else try {
  OPC_CheckPredicate, 35,                    // 1405:       check predicate 35
  OPC_Decode, 243, 21, 216, 2,               // 1407:       decode to VLD3q16_UPD using decoder 344
                                             // 1407:      }
                                             // 1407:     }
  2, 0,                                      // 1412:     case 0x2: {
  OPC_Scope, 11,                             // 1414:      try {
  OPC_CheckField, 0, 4, 15,                  // 1416:       check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1420:       check predicate 35
  OPC_Decode, 246, 21, 216, 2,               // 1422:       decode to VLD3q32 using decoder 344
                                             // 1422:      } else try {
  OPC_CheckPredicate, 35,                    // 1427:       check predicate 35
  OPC_Decode, 248, 21, 216, 2,               // 1429:       decode to VLD3q32_UPD using decoder 344
                                             // 1429:      }
                                             // 1429:     }
                                             // 1429:     } // switch Inst[7:6]
                                             // 1429:    }
  233, 3, 0,                                 // 1434:    case 0x1e9: {
  OPC_Scope, 11,                             // 1437:     try {
  OPC_CheckField, 0, 4, 15,                  // 1439:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1443:      check predicate 35
  OPC_Decode, 254, 20, 209, 2,               // 1445:      decode to VLD2LNd16 using decoder 337
                                             // 1445:     } else try {
  OPC_CheckPredicate, 35,                    // 1450:      check predicate 35
  OPC_Decode, 129, 21, 209, 2,               // 1452:      decode to VLD2LNd16_UPD using decoder 337
                                             // 1452:     }
                                             // 1452:    }
                                             // 1452:    } // switch Inst[31:23]
                                             // 1452:   }
                                             // 1452:   } // switch Inst[21:20]
                                             // 1452:  }
  1, 0,                                      // 1457:  case 0x1: {
  OPC_SwitchField, 20, 2,                    // 1459:   switch Inst[21:20] {
  0, 25,                                     // 1462:   case 0x0: {
  OPC_CheckField, 23, 9, 233, 3,             // 1464:    check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 1469:    try {
  OPC_CheckField, 0, 4, 15,                  // 1471:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1475:     check predicate 35
  OPC_Decode, 157, 29, 208, 2,               // 1477:     decode to VST2LNq16 using decoder 336
                                             // 1477:    } else try {
  OPC_CheckPredicate, 35,                    // 1482:     check predicate 35
  OPC_Decode, 160, 29, 208, 2,               // 1484:     decode to VST2LNq16_UPD using decoder 336
                                             // 1484:    }
                                             // 1484:   }
  2, 0,                                      // 1489:   case 0x2: {
  OPC_CheckField, 23, 9, 233, 3,             // 1491:    check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 1496:    try {
  OPC_CheckField, 0, 4, 15,                  // 1498:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1502:     check predicate 35
  OPC_Decode, 138, 21, 209, 2,               // 1504:     decode to VLD2LNq16 using decoder 337
                                             // 1504:    } else try {
  OPC_CheckPredicate, 35,                    // 1509:     check predicate 35
  OPC_Decode, 141, 21, 209, 2,               // 1511:     decode to VLD2LNq16_UPD using decoder 337
                                             // 1511:    }
                                             // 1511:   }
                                             // 1511:   } // switch Inst[21:20]
                                             // 1511:  }
                                             // 1511:  } // switch Inst[5]
                                             // 1511: }
  6, 158, 3,                                 // 1516: case 0x6: {
  OPC_SwitchField, 20, 2,                    // 1519:  switch Inst[21:20] {
  0, 204, 1,                                 // 1522:  case 0x0: {
  OPC_SwitchField, 23, 9,                    // 1525:   switch Inst[31:23] {
  232, 3, 147, 1,                            // 1528:   case 0x1e8: {
  OPC_SwitchField, 6, 2,                     // 1532:    switch Inst[7:6] {
  0, 34,                                     // 1535:    case 0x0: {
  OPC_Scope, 25,                             // 1537:     try {
  OPC_SwitchField, 0, 4,                     // 1539:      switch Inst[3:0] {
  13, 7,                                     // 1542:      case 0xd: {
  OPC_CheckPredicate, 35,                    // 1544:       check predicate 35
  OPC_Decode, 233, 28, 210, 2,               // 1546:       decode to VST1d8Twb_fixed using decoder 338
                                             // 1546:      }
  15, 0,                                     // 1551:      case 0xf: {
  OPC_CheckPredicate, 35,                    // 1553:       check predicate 35
  OPC_CheckField, 5, 1, 0,                   // 1555:       check Inst[5] == 0x0
  OPC_Decode, 229, 28, 210, 2,               // 1559:       decode to VST1d8T using decoder 338
                                             // 1559:      }
                                             // 1559:      } // switch Inst[3:0]
                                             // 1559:     } else try {
  OPC_CheckPredicate, 35,                    // 1564:      check predicate 35
  OPC_Decode, 234, 28, 210, 2,               // 1566:      decode to VST1d8Twb_register using decoder 338
                                             // 1566:     }
                                             // 1566:    }
  1, 34,                                     // 1571:    case 0x1: {
  OPC_Scope, 25,                             // 1573:     try {
  OPC_SwitchField, 0, 4,                     // 1575:      switch Inst[3:0] {
  13, 7,                                     // 1578:      case 0xd: {
  OPC_CheckPredicate, 35,                    // 1580:       check predicate 35
  OPC_Decode, 188, 28, 210, 2,               // 1582:       decode to VST1d16Twb_fixed using decoder 338
                                             // 1582:      }
  15, 0,                                     // 1587:      case 0xf: {
  OPC_CheckPredicate, 35,                    // 1589:       check predicate 35
  OPC_CheckField, 5, 1, 0,                   // 1591:       check Inst[5] == 0x0
  OPC_Decode, 184, 28, 210, 2,               // 1595:       decode to VST1d16T using decoder 338
                                             // 1595:      }
                                             // 1595:      } // switch Inst[3:0]
                                             // 1595:     } else try {
  OPC_CheckPredicate, 35,                    // 1600:      check predicate 35
  OPC_Decode, 189, 28, 210, 2,               // 1602:      decode to VST1d16Twb_register using decoder 338
                                             // 1602:     }
                                             // 1602:    }
  2, 34,                                     // 1607:    case 0x2: {
  OPC_Scope, 25,                             // 1609:     try {
  OPC_SwitchField, 0, 4,                     // 1611:      switch Inst[3:0] {
  13, 7,                                     // 1614:      case 0xd: {
  OPC_CheckPredicate, 35,                    // 1616:       check predicate 35
  OPC_Decode, 203, 28, 210, 2,               // 1618:       decode to VST1d32Twb_fixed using decoder 338
                                             // 1618:      }
  15, 0,                                     // 1623:      case 0xf: {
  OPC_CheckPredicate, 35,                    // 1625:       check predicate 35
  OPC_CheckField, 5, 1, 0,                   // 1627:       check Inst[5] == 0x0
  OPC_Decode, 199, 28, 210, 2,               // 1631:       decode to VST1d32T using decoder 338
                                             // 1631:      }
                                             // 1631:      } // switch Inst[3:0]
                                             // 1631:     } else try {
  OPC_CheckPredicate, 35,                    // 1636:      check predicate 35
  OPC_Decode, 204, 28, 210, 2,               // 1638:      decode to VST1d32Twb_register using decoder 338
                                             // 1638:     }
                                             // 1638:    }
  3, 0,                                      // 1643:    case 0x3: {
  OPC_Scope, 25,                             // 1645:     try {
  OPC_SwitchField, 0, 4,                     // 1647:      switch Inst[3:0] {
  13, 7,                                     // 1650:      case 0xd: {
  OPC_CheckPredicate, 35,                    // 1652:       check predicate 35
  OPC_Decode, 218, 28, 210, 2,               // 1654:       decode to VST1d64Twb_fixed using decoder 338
                                             // 1654:      }
  15, 0,                                     // 1659:      case 0xf: {
  OPC_CheckPredicate, 35,                    // 1661:       check predicate 35
  OPC_CheckField, 5, 1, 0,                   // 1663:       check Inst[5] == 0x0
  OPC_Decode, 214, 28, 210, 2,               // 1667:       decode to VST1d64T using decoder 338
                                             // 1667:      }
                                             // 1667:      } // switch Inst[3:0]
                                             // 1667:     } else try {
  OPC_CheckPredicate, 35,                    // 1672:      check predicate 35
  OPC_Decode, 219, 28, 210, 2,               // 1674:      decode to VST1d64Twb_register using decoder 338
                                             // 1674:     }
                                             // 1674:    }
                                             // 1674:    } // switch Inst[7:6]
                                             // 1674:   }
  233, 3, 0,                                 // 1679:   case 0x1e9: {
  OPC_SwitchField, 4, 2,                     // 1682:    switch Inst[5:4] {
  0, 20,                                     // 1685:    case 0x0: {
  OPC_Scope, 11,                             // 1687:     try {
  OPC_CheckField, 0, 4, 15,                  // 1689:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1693:      check predicate 35
  OPC_Decode, 201, 29, 211, 2,               // 1695:      decode to VST3LNd16 using decoder 339
                                             // 1695:     } else try {
  OPC_CheckPredicate, 35,                    // 1700:      check predicate 35
  OPC_Decode, 204, 29, 211, 2,               // 1702:      decode to VST3LNd16_UPD using decoder 339
                                             // 1702:     }
                                             // 1702:    }
  2, 0,                                      // 1707:    case 0x2: {
  OPC_Scope, 11,                             // 1709:     try {
  OPC_CheckField, 0, 4, 15,                  // 1711:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1715:      check predicate 35
  OPC_Decode, 213, 29, 211, 2,               // 1717:      decode to VST3LNq16 using decoder 339
                                             // 1717:     } else try {
  OPC_CheckPredicate, 35,                    // 1722:      check predicate 35
  OPC_Decode, 216, 29, 211, 2,               // 1724:      decode to VST3LNq16_UPD using decoder 339
                                             // 1724:     }
                                             // 1724:    }
                                             // 1724:    } // switch Inst[5:4]
                                             // 1724:   }
                                             // 1724:   } // switch Inst[31:23]
                                             // 1724:  }
  2, 0,                                      // 1729:  case 0x2: {
  OPC_SwitchField, 5, 1,                     // 1731:   switch Inst[5] {
  0, 165, 1,                                 // 1734:   case 0x0: {
  OPC_SwitchField, 23, 9,                    // 1737:    switch Inst[31:23] {
  232, 3, 131, 1,                            // 1740:    case 0x1e8: {
  OPC_SwitchField, 6, 2,                     // 1744:     switch Inst[7:6] {
  0, 30,                                     // 1747:     case 0x0: {
  OPC_Scope, 21,                             // 1749:      try {
  OPC_SwitchField, 0, 4,                     // 1751:       switch Inst[3:0] {
  13, 7,                                     // 1754:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 1756:        check predicate 35
  OPC_Decode, 184, 20, 210, 2,               // 1758:        decode to VLD1d8Twb_fixed using decoder 338
                                             // 1758:       }
  15, 0,                                     // 1763:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 1765:        check predicate 35
  OPC_Decode, 180, 20, 210, 2,               // 1767:        decode to VLD1d8T using decoder 338
                                             // 1767:       }
                                             // 1767:       } // switch Inst[3:0]
                                             // 1767:      } else try {
  OPC_CheckPredicate, 35,                    // 1772:       check predicate 35
  OPC_Decode, 185, 20, 210, 2,               // 1774:       decode to VLD1d8Twb_register using decoder 338
                                             // 1774:      }
                                             // 1774:     }
  1, 30,                                     // 1779:     case 0x1: {
  OPC_Scope, 21,                             // 1781:      try {
  OPC_SwitchField, 0, 4,                     // 1783:       switch Inst[3:0] {
  13, 7,                                     // 1786:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 1788:        check predicate 35
  OPC_Decode, 139, 20, 210, 2,               // 1790:        decode to VLD1d16Twb_fixed using decoder 338
                                             // 1790:       }
  15, 0,                                     // 1795:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 1797:        check predicate 35
  OPC_Decode, 135, 20, 210, 2,               // 1799:        decode to VLD1d16T using decoder 338
                                             // 1799:       }
                                             // 1799:       } // switch Inst[3:0]
                                             // 1799:      } else try {
  OPC_CheckPredicate, 35,                    // 1804:       check predicate 35
  OPC_Decode, 140, 20, 210, 2,               // 1806:       decode to VLD1d16Twb_register using decoder 338
                                             // 1806:      }
                                             // 1806:     }
  2, 30,                                     // 1811:     case 0x2: {
  OPC_Scope, 21,                             // 1813:      try {
  OPC_SwitchField, 0, 4,                     // 1815:       switch Inst[3:0] {
  13, 7,                                     // 1818:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 1820:        check predicate 35
  OPC_Decode, 154, 20, 210, 2,               // 1822:        decode to VLD1d32Twb_fixed using decoder 338
                                             // 1822:       }
  15, 0,                                     // 1827:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 1829:        check predicate 35
  OPC_Decode, 150, 20, 210, 2,               // 1831:        decode to VLD1d32T using decoder 338
                                             // 1831:       }
                                             // 1831:       } // switch Inst[3:0]
                                             // 1831:      } else try {
  OPC_CheckPredicate, 35,                    // 1836:       check predicate 35
  OPC_Decode, 155, 20, 210, 2,               // 1838:       decode to VLD1d32Twb_register using decoder 338
                                             // 1838:      }
                                             // 1838:     }
  3, 0,                                      // 1843:     case 0x3: {
  OPC_Scope, 21,                             // 1845:      try {
  OPC_SwitchField, 0, 4,                     // 1847:       switch Inst[3:0] {
  13, 7,                                     // 1850:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 1852:        check predicate 35
  OPC_Decode, 169, 20, 210, 2,               // 1854:        decode to VLD1d64Twb_fixed using decoder 338
                                             // 1854:       }
  15, 0,                                     // 1859:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 1861:        check predicate 35
  OPC_Decode, 165, 20, 210, 2,               // 1863:        decode to VLD1d64T using decoder 338
                                             // 1863:       }
                                             // 1863:       } // switch Inst[3:0]
                                             // 1863:      } else try {
  OPC_CheckPredicate, 35,                    // 1868:       check predicate 35
  OPC_Decode, 170, 20, 210, 2,               // 1870:       decode to VLD1d64Twb_register using decoder 338
                                             // 1870:      }
                                             // 1870:     }
                                             // 1870:     } // switch Inst[7:6]
                                             // 1870:    }
  233, 3, 0,                                 // 1875:    case 0x1e9: {
  OPC_CheckField, 4, 1, 0,                   // 1878:     check Inst[4] == 0x0
  OPC_Scope, 11,                             // 1882:     try {
  OPC_CheckField, 0, 4, 15,                  // 1884:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1888:      check predicate 35
  OPC_Decode, 209, 21, 212, 2,               // 1890:      decode to VLD3LNd16 using decoder 340
                                             // 1890:     } else try {
  OPC_CheckPredicate, 35,                    // 1895:      check predicate 35
  OPC_Decode, 212, 21, 212, 2,               // 1897:      decode to VLD3LNd16_UPD using decoder 340
                                             // 1897:     }
                                             // 1897:    }
                                             // 1897:    } // switch Inst[31:23]
                                             // 1897:   }
  1, 0,                                      // 1902:   case 0x1: {
  OPC_CheckField, 4, 1, 0,                   // 1904:    check Inst[4] == 0x0
  OPC_CheckField, 23, 9, 233, 3,             // 1908:    check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 1913:    try {
  OPC_CheckField, 0, 4, 15,                  // 1915:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 1919:     check predicate 35
  OPC_Decode, 221, 21, 212, 2,               // 1921:     decode to VLD3LNq16 using decoder 340
                                             // 1921:    } else try {
  OPC_CheckPredicate, 35,                    // 1926:     check predicate 35
  OPC_Decode, 224, 21, 212, 2,               // 1928:     decode to VLD3LNq16_UPD using decoder 340
                                             // 1928:    }
                                             // 1928:   }
                                             // 1928:   } // switch Inst[5]
                                             // 1928:  }
                                             // 1928:  } // switch Inst[21:20]
                                             // 1928: }
  7, 139, 3,                                 // 1933: case 0x7: {
  OPC_SwitchField, 5, 1,                     // 1936:  switch Inst[5] {
  0, 202, 2,                                 // 1939:  case 0x0: {
  OPC_SwitchField, 20, 2,                    // 1942:   switch Inst[21:20] {
  0, 161, 1,                                 // 1945:   case 0x0: {
  OPC_SwitchField, 23, 9,                    // 1948:    switch Inst[31:23] {
  232, 3, 131, 1,                            // 1951:    case 0x1e8: {
  OPC_SwitchField, 6, 2,                     // 1955:     switch Inst[7:6] {
  0, 30,                                     // 1958:     case 0x0: {
  OPC_Scope, 21,                             // 1960:      try {
  OPC_SwitchField, 0, 4,                     // 1962:       switch Inst[3:0] {
  13, 7,                                     // 1965:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 1967:        check predicate 35
  OPC_Decode, 235, 28, 210, 2,               // 1969:        decode to VST1d8wb_fixed using decoder 338
                                             // 1969:       }
  15, 0,                                     // 1974:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 1976:        check predicate 35
  OPC_Decode, 222, 28, 210, 2,               // 1978:        decode to VST1d8 using decoder 338
                                             // 1978:       }
                                             // 1978:       } // switch Inst[3:0]
                                             // 1978:      } else try {
  OPC_CheckPredicate, 35,                    // 1983:       check predicate 35
  OPC_Decode, 236, 28, 210, 2,               // 1985:       decode to VST1d8wb_register using decoder 338
                                             // 1985:      }
                                             // 1985:     }
  1, 30,                                     // 1990:     case 0x1: {
  OPC_Scope, 21,                             // 1992:      try {
  OPC_SwitchField, 0, 4,                     // 1994:       switch Inst[3:0] {
  13, 7,                                     // 1997:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 1999:        check predicate 35
  OPC_Decode, 190, 28, 210, 2,               // 2001:        decode to VST1d16wb_fixed using decoder 338
                                             // 2001:       }
  15, 0,                                     // 2006:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2008:        check predicate 35
  OPC_Decode, 177, 28, 210, 2,               // 2010:        decode to VST1d16 using decoder 338
                                             // 2010:       }
                                             // 2010:       } // switch Inst[3:0]
                                             // 2010:      } else try {
  OPC_CheckPredicate, 35,                    // 2015:       check predicate 35
  OPC_Decode, 191, 28, 210, 2,               // 2017:       decode to VST1d16wb_register using decoder 338
                                             // 2017:      }
                                             // 2017:     }
  2, 30,                                     // 2022:     case 0x2: {
  OPC_Scope, 21,                             // 2024:      try {
  OPC_SwitchField, 0, 4,                     // 2026:       switch Inst[3:0] {
  13, 7,                                     // 2029:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2031:        check predicate 35
  OPC_Decode, 205, 28, 210, 2,               // 2033:        decode to VST1d32wb_fixed using decoder 338
                                             // 2033:       }
  15, 0,                                     // 2038:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2040:        check predicate 35
  OPC_Decode, 192, 28, 210, 2,               // 2042:        decode to VST1d32 using decoder 338
                                             // 2042:       }
                                             // 2042:       } // switch Inst[3:0]
                                             // 2042:      } else try {
  OPC_CheckPredicate, 35,                    // 2047:       check predicate 35
  OPC_Decode, 206, 28, 210, 2,               // 2049:       decode to VST1d32wb_register using decoder 338
                                             // 2049:      }
                                             // 2049:     }
  3, 0,                                      // 2054:     case 0x3: {
  OPC_Scope, 21,                             // 2056:      try {
  OPC_SwitchField, 0, 4,                     // 2058:       switch Inst[3:0] {
  13, 7,                                     // 2061:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2063:        check predicate 35
  OPC_Decode, 220, 28, 210, 2,               // 2065:        decode to VST1d64wb_fixed using decoder 338
                                             // 2065:       }
  15, 0,                                     // 2070:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2072:        check predicate 35
  OPC_Decode, 207, 28, 210, 2,               // 2074:        decode to VST1d64 using decoder 338
                                             // 2074:       }
                                             // 2074:       } // switch Inst[3:0]
                                             // 2074:      } else try {
  OPC_CheckPredicate, 35,                    // 2079:       check predicate 35
  OPC_Decode, 221, 28, 210, 2,               // 2081:       decode to VST1d64wb_register using decoder 338
                                             // 2081:      }
                                             // 2081:     }
                                             // 2081:     } // switch Inst[7:6]
                                             // 2081:    }
  233, 3, 0,                                 // 2086:    case 0x1e9: {
  OPC_Scope, 11,                             // 2089:     try {
  OPC_CheckField, 0, 4, 15,                  // 2091:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 2095:      check predicate 35
  OPC_Decode, 248, 29, 214, 2,               // 2097:      decode to VST4LNd16 using decoder 342
                                             // 2097:     } else try {
  OPC_CheckPredicate, 35,                    // 2102:      check predicate 35
  OPC_Decode, 251, 29, 214, 2,               // 2104:      decode to VST4LNd16_UPD using decoder 342
                                             // 2104:     }
                                             // 2104:    }
                                             // 2104:    } // switch Inst[31:23]
                                             // 2104:   }
  2, 0,                                      // 2109:   case 0x2: {
  OPC_SwitchField, 23, 9,                    // 2111:    switch Inst[31:23] {
  232, 3, 131, 1,                            // 2114:    case 0x1e8: {
  OPC_SwitchField, 6, 2,                     // 2118:     switch Inst[7:6] {
  0, 30,                                     // 2121:     case 0x0: {
  OPC_Scope, 21,                             // 2123:      try {
  OPC_SwitchField, 0, 4,                     // 2125:       switch Inst[3:0] {
  13, 7,                                     // 2128:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2130:        check predicate 35
  OPC_Decode, 186, 20, 210, 2,               // 2132:        decode to VLD1d8wb_fixed using decoder 338
                                             // 2132:       }
  15, 0,                                     // 2137:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2139:        check predicate 35
  OPC_Decode, 173, 20, 210, 2,               // 2141:        decode to VLD1d8 using decoder 338
                                             // 2141:       }
                                             // 2141:       } // switch Inst[3:0]
                                             // 2141:      } else try {
  OPC_CheckPredicate, 35,                    // 2146:       check predicate 35
  OPC_Decode, 187, 20, 210, 2,               // 2148:       decode to VLD1d8wb_register using decoder 338
                                             // 2148:      }
                                             // 2148:     }
  1, 30,                                     // 2153:     case 0x1: {
  OPC_Scope, 21,                             // 2155:      try {
  OPC_SwitchField, 0, 4,                     // 2157:       switch Inst[3:0] {
  13, 7,                                     // 2160:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2162:        check predicate 35
  OPC_Decode, 141, 20, 210, 2,               // 2164:        decode to VLD1d16wb_fixed using decoder 338
                                             // 2164:       }
  15, 0,                                     // 2169:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2171:        check predicate 35
  OPC_Decode, 128, 20, 210, 2,               // 2173:        decode to VLD1d16 using decoder 338
                                             // 2173:       }
                                             // 2173:       } // switch Inst[3:0]
                                             // 2173:      } else try {
  OPC_CheckPredicate, 35,                    // 2178:       check predicate 35
  OPC_Decode, 142, 20, 210, 2,               // 2180:       decode to VLD1d16wb_register using decoder 338
                                             // 2180:      }
                                             // 2180:     }
  2, 30,                                     // 2185:     case 0x2: {
  OPC_Scope, 21,                             // 2187:      try {
  OPC_SwitchField, 0, 4,                     // 2189:       switch Inst[3:0] {
  13, 7,                                     // 2192:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2194:        check predicate 35
  OPC_Decode, 156, 20, 210, 2,               // 2196:        decode to VLD1d32wb_fixed using decoder 338
                                             // 2196:       }
  15, 0,                                     // 2201:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2203:        check predicate 35
  OPC_Decode, 143, 20, 210, 2,               // 2205:        decode to VLD1d32 using decoder 338
                                             // 2205:       }
                                             // 2205:       } // switch Inst[3:0]
                                             // 2205:      } else try {
  OPC_CheckPredicate, 35,                    // 2210:       check predicate 35
  OPC_Decode, 157, 20, 210, 2,               // 2212:       decode to VLD1d32wb_register using decoder 338
                                             // 2212:      }
                                             // 2212:     }
  3, 0,                                      // 2217:     case 0x3: {
  OPC_Scope, 21,                             // 2219:      try {
  OPC_SwitchField, 0, 4,                     // 2221:       switch Inst[3:0] {
  13, 7,                                     // 2224:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2226:        check predicate 35
  OPC_Decode, 171, 20, 210, 2,               // 2228:        decode to VLD1d64wb_fixed using decoder 338
                                             // 2228:       }
  15, 0,                                     // 2233:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2235:        check predicate 35
  OPC_Decode, 158, 20, 210, 2,               // 2237:        decode to VLD1d64 using decoder 338
                                             // 2237:       }
                                             // 2237:       } // switch Inst[3:0]
                                             // 2237:      } else try {
  OPC_CheckPredicate, 35,                    // 2242:       check predicate 35
  OPC_Decode, 172, 20, 210, 2,               // 2244:       decode to VLD1d64wb_register using decoder 338
                                             // 2244:      }
                                             // 2244:     }
                                             // 2244:     } // switch Inst[7:6]
                                             // 2244:    }
  233, 3, 0,                                 // 2249:    case 0x1e9: {
  OPC_Scope, 11,                             // 2252:     try {
  OPC_CheckField, 0, 4, 15,                  // 2254:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 2258:      check predicate 35
  OPC_Decode, 155, 22, 215, 2,               // 2260:      decode to VLD4LNd16 using decoder 343
                                             // 2260:     } else try {
  OPC_CheckPredicate, 35,                    // 2265:      check predicate 35
  OPC_Decode, 158, 22, 215, 2,               // 2267:      decode to VLD4LNd16_UPD using decoder 343
                                             // 2267:     }
                                             // 2267:    }
                                             // 2267:    } // switch Inst[31:23]
                                             // 2267:   }
                                             // 2267:   } // switch Inst[21:20]
                                             // 2267:  }
  1, 0,                                      // 2272:  case 0x1: {
  OPC_SwitchField, 20, 2,                    // 2274:   switch Inst[21:20] {
  0, 25,                                     // 2277:   case 0x0: {
  OPC_CheckField, 23, 9, 233, 3,             // 2279:    check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 2284:    try {
  OPC_CheckField, 0, 4, 15,                  // 2286:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 2290:     check predicate 35
  OPC_Decode, 132, 30, 214, 2,               // 2292:     decode to VST4LNq16 using decoder 342
                                             // 2292:    } else try {
  OPC_CheckPredicate, 35,                    // 2297:     check predicate 35
  OPC_Decode, 135, 30, 214, 2,               // 2299:     decode to VST4LNq16_UPD using decoder 342
                                             // 2299:    }
                                             // 2299:   }
  2, 0,                                      // 2304:   case 0x2: {
  OPC_CheckField, 23, 9, 233, 3,             // 2306:    check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 2311:    try {
  OPC_CheckField, 0, 4, 15,                  // 2313:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 2317:     check predicate 35
  OPC_Decode, 167, 22, 215, 2,               // 2319:     decode to VLD4LNq16 using decoder 343
                                             // 2319:    } else try {
  OPC_CheckPredicate, 35,                    // 2324:     check predicate 35
  OPC_Decode, 170, 22, 215, 2,               // 2326:     decode to VLD4LNq16_UPD using decoder 343
                                             // 2326:    }
                                             // 2326:   }
                                             // 2326:   } // switch Inst[21:20]
                                             // 2326:  }
                                             // 2326:  } // switch Inst[5]
                                             // 2326: }
  8, 164, 2,                                 // 2331: case 0x8: {
  OPC_SwitchField, 6, 1,                     // 2334:  switch Inst[6] {
  0, 199, 1,                                 // 2337:  case 0x0: {
  OPC_SwitchField, 20, 2,                    // 2340:   switch Inst[21:20] {
  0, 96,                                     // 2343:   case 0x0: {
  OPC_SwitchField, 23, 9,                    // 2345:    switch Inst[31:23] {
  232, 3, 67,                                // 2348:    case 0x1e8: {
  OPC_SwitchField, 7, 1,                     // 2351:     switch Inst[7] {
  0, 30,                                     // 2354:     case 0x0: {
  OPC_Scope, 21,                             // 2356:      try {
  OPC_SwitchField, 0, 4,                     // 2358:       switch Inst[3:0] {
  13, 7,                                     // 2361:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2363:        check predicate 35
  OPC_Decode, 181, 29, 213, 2,               // 2365:        decode to VST2d8wb_fixed using decoder 341
                                             // 2365:       }
  15, 0,                                     // 2370:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2372:        check predicate 35
  OPC_Decode, 180, 29, 213, 2,               // 2374:        decode to VST2d8 using decoder 341
                                             // 2374:       }
                                             // 2374:       } // switch Inst[3:0]
                                             // 2374:      } else try {
  OPC_CheckPredicate, 35,                    // 2379:       check predicate 35
  OPC_Decode, 182, 29, 213, 2,               // 2381:       decode to VST2d8wb_register using decoder 341
                                             // 2381:      }
                                             // 2381:     }
  1, 0,                                      // 2386:     case 0x1: {
  OPC_Scope, 21,                             // 2388:      try {
  OPC_SwitchField, 0, 4,                     // 2390:       switch Inst[3:0] {
  13, 7,                                     // 2393:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2395:        check predicate 35
  OPC_Decode, 178, 29, 213, 2,               // 2397:        decode to VST2d32wb_fixed using decoder 341
                                             // 2397:       }
  15, 0,                                     // 2402:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2404:        check predicate 35
  OPC_Decode, 177, 29, 213, 2,               // 2406:        decode to VST2d32 using decoder 341
                                             // 2406:       }
                                             // 2406:       } // switch Inst[3:0]
                                             // 2406:      } else try {
  OPC_CheckPredicate, 35,                    // 2411:       check predicate 35
  OPC_Decode, 179, 29, 213, 2,               // 2413:       decode to VST2d32wb_register using decoder 341
                                             // 2413:      }
                                             // 2413:     }
                                             // 2413:     } // switch Inst[7]
                                             // 2413:    }
  233, 3, 0,                                 // 2418:    case 0x1e9: {
  OPC_Scope, 11,                             // 2421:     try {
  OPC_CheckField, 0, 4, 15,                  // 2423:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 2427:      check predicate 35
  OPC_Decode, 167, 28, 206, 2,               // 2429:      decode to VST1LNd32 using decoder 334
                                             // 2429:     } else try {
  OPC_CheckPredicate, 35,                    // 2434:      check predicate 35
  OPC_Decode, 168, 28, 206, 2,               // 2436:      decode to VST1LNd32_UPD using decoder 334
                                             // 2436:     }
                                             // 2436:    }
                                             // 2436:    } // switch Inst[31:23]
                                             // 2436:   }
  2, 0,                                      // 2441:   case 0x2: {
  OPC_SwitchField, 23, 9,                    // 2443:    switch Inst[31:23] {
  232, 3, 67,                                // 2446:    case 0x1e8: {
  OPC_SwitchField, 7, 1,                     // 2449:     switch Inst[7] {
  0, 30,                                     // 2452:     case 0x0: {
  OPC_Scope, 21,                             // 2454:      try {
  OPC_SwitchField, 0, 4,                     // 2456:       switch Inst[3:0] {
  13, 7,                                     // 2459:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2461:        check predicate 35
  OPC_Decode, 162, 21, 213, 2,               // 2463:        decode to VLD2d8wb_fixed using decoder 341
                                             // 2463:       }
  15, 0,                                     // 2468:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2470:        check predicate 35
  OPC_Decode, 161, 21, 213, 2,               // 2472:        decode to VLD2d8 using decoder 341
                                             // 2472:       }
                                             // 2472:       } // switch Inst[3:0]
                                             // 2472:      } else try {
  OPC_CheckPredicate, 35,                    // 2477:       check predicate 35
  OPC_Decode, 163, 21, 213, 2,               // 2479:       decode to VLD2d8wb_register using decoder 341
                                             // 2479:      }
                                             // 2479:     }
  1, 0,                                      // 2484:     case 0x1: {
  OPC_Scope, 21,                             // 2486:      try {
  OPC_SwitchField, 0, 4,                     // 2488:       switch Inst[3:0] {
  13, 7,                                     // 2491:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2493:        check predicate 35
  OPC_Decode, 159, 21, 213, 2,               // 2495:        decode to VLD2d32wb_fixed using decoder 341
                                             // 2495:       }
  15, 0,                                     // 2500:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2502:        check predicate 35
  OPC_Decode, 158, 21, 213, 2,               // 2504:        decode to VLD2d32 using decoder 341
                                             // 2504:       }
                                             // 2504:       } // switch Inst[3:0]
                                             // 2504:      } else try {
  OPC_CheckPredicate, 35,                    // 2509:       check predicate 35
  OPC_Decode, 160, 21, 213, 2,               // 2511:       decode to VLD2d32wb_register using decoder 341
                                             // 2511:      }
                                             // 2511:     }
                                             // 2511:     } // switch Inst[7]
                                             // 2511:    }
  233, 3, 0,                                 // 2516:    case 0x1e9: {
  OPC_Scope, 11,                             // 2519:     try {
  OPC_CheckField, 0, 4, 15,                  // 2521:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 2525:      check predicate 35
  OPC_Decode, 246, 19, 207, 2,               // 2527:      decode to VLD1LNd32 using decoder 335
                                             // 2527:     } else try {
  OPC_CheckPredicate, 35,                    // 2532:      check predicate 35
  OPC_Decode, 247, 19, 207, 2,               // 2534:      decode to VLD1LNd32_UPD using decoder 335
                                             // 2534:     }
                                             // 2534:    }
                                             // 2534:    } // switch Inst[31:23]
                                             // 2534:   }
                                             // 2534:   } // switch Inst[21:20]
                                             // 2534:  }
  1, 0,                                      // 2539:  case 0x1: {
  OPC_SwitchField, 20, 2,                    // 2541:   switch Inst[21:20] {
  0, 39,                                     // 2544:   case 0x0: {
  OPC_CheckField, 7, 1, 0,                   // 2546:    check Inst[7] == 0x0
  OPC_CheckField, 23, 9, 232, 3,             // 2550:    check Inst[31:23] == 0x1e8
  OPC_Scope, 21,                             // 2555:    try {
  OPC_SwitchField, 0, 4,                     // 2557:     switch Inst[3:0] {
  13, 7,                                     // 2560:     case 0xd: {
  OPC_CheckPredicate, 35,                    // 2562:      check predicate 35
  OPC_Decode, 175, 29, 213, 2,               // 2564:      decode to VST2d16wb_fixed using decoder 341
                                             // 2564:     }
  15, 0,                                     // 2569:     case 0xf: {
  OPC_CheckPredicate, 35,                    // 2571:      check predicate 35
  OPC_Decode, 174, 29, 213, 2,               // 2573:      decode to VST2d16 using decoder 341
                                             // 2573:     }
                                             // 2573:     } // switch Inst[3:0]
                                             // 2573:    } else try {
  OPC_CheckPredicate, 35,                    // 2578:     check predicate 35
  OPC_Decode, 176, 29, 213, 2,               // 2580:     decode to VST2d16wb_register using decoder 341
                                             // 2580:    }
                                             // 2580:   }
  2, 0,                                      // 2585:   case 0x2: {
  OPC_CheckField, 7, 1, 0,                   // 2587:    check Inst[7] == 0x0
  OPC_CheckField, 23, 9, 232, 3,             // 2591:    check Inst[31:23] == 0x1e8
  OPC_Scope, 21,                             // 2596:    try {
  OPC_SwitchField, 0, 4,                     // 2598:     switch Inst[3:0] {
  13, 7,                                     // 2601:     case 0xd: {
  OPC_CheckPredicate, 35,                    // 2603:      check predicate 35
  OPC_Decode, 156, 21, 213, 2,               // 2605:      decode to VLD2d16wb_fixed using decoder 341
                                             // 2605:     }
  15, 0,                                     // 2610:     case 0xf: {
  OPC_CheckPredicate, 35,                    // 2612:      check predicate 35
  OPC_Decode, 155, 21, 213, 2,               // 2614:      decode to VLD2d16 using decoder 341
                                             // 2614:     }
                                             // 2614:     } // switch Inst[3:0]
                                             // 2614:    } else try {
  OPC_CheckPredicate, 35,                    // 2619:     check predicate 35
  OPC_Decode, 157, 21, 213, 2,               // 2621:     decode to VLD2d16wb_register using decoder 341
                                             // 2621:    }
                                             // 2621:   }
                                             // 2621:   } // switch Inst[21:20]
                                             // 2621:  }
                                             // 2621:  } // switch Inst[6]
                                             // 2621: }
  9, 228, 2,                                 // 2626: case 0x9: {
  OPC_SwitchField, 6, 1,                     // 2629:  switch Inst[6] {
  0, 207, 1,                                 // 2632:  case 0x0: {
  OPC_SwitchField, 20, 2,                    // 2635:   switch Inst[21:20] {
  0, 100,                                    // 2638:   case 0x0: {
  OPC_SwitchField, 23, 9,                    // 2640:    switch Inst[31:23] {
  232, 3, 67,                                // 2643:    case 0x1e8: {
  OPC_SwitchField, 7, 1,                     // 2646:     switch Inst[7] {
  0, 30,                                     // 2649:     case 0x0: {
  OPC_Scope, 21,                             // 2651:      try {
  OPC_SwitchField, 0, 4,                     // 2653:       switch Inst[3:0] {
  13, 7,                                     // 2656:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2658:        check predicate 35
  OPC_Decode, 172, 29, 213, 2,               // 2660:        decode to VST2b8wb_fixed using decoder 341
                                             // 2660:       }
  15, 0,                                     // 2665:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2667:        check predicate 35
  OPC_Decode, 171, 29, 213, 2,               // 2669:        decode to VST2b8 using decoder 341
                                             // 2669:       }
                                             // 2669:       } // switch Inst[3:0]
                                             // 2669:      } else try {
  OPC_CheckPredicate, 35,                    // 2674:       check predicate 35
  OPC_Decode, 173, 29, 213, 2,               // 2676:       decode to VST2b8wb_register using decoder 341
                                             // 2676:      }
                                             // 2676:     }
  1, 0,                                      // 2681:     case 0x1: {
  OPC_Scope, 21,                             // 2683:      try {
  OPC_SwitchField, 0, 4,                     // 2685:       switch Inst[3:0] {
  13, 7,                                     // 2688:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2690:        check predicate 35
  OPC_Decode, 169, 29, 213, 2,               // 2692:        decode to VST2b32wb_fixed using decoder 341
                                             // 2692:       }
  15, 0,                                     // 2697:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2699:        check predicate 35
  OPC_Decode, 168, 29, 213, 2,               // 2701:        decode to VST2b32 using decoder 341
                                             // 2701:       }
                                             // 2701:       } // switch Inst[3:0]
                                             // 2701:      } else try {
  OPC_CheckPredicate, 35,                    // 2706:       check predicate 35
  OPC_Decode, 170, 29, 213, 2,               // 2708:       decode to VST2b32wb_register using decoder 341
                                             // 2708:      }
                                             // 2708:     }
                                             // 2708:     } // switch Inst[7]
                                             // 2708:    }
  233, 3, 0,                                 // 2713:    case 0x1e9: {
  OPC_CheckField, 5, 1, 0,                   // 2716:     check Inst[5] == 0x0
  OPC_Scope, 11,                             // 2720:     try {
  OPC_CheckField, 0, 4, 15,                  // 2722:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 2726:      check predicate 35
  OPC_Decode, 149, 29, 208, 2,               // 2728:      decode to VST2LNd32 using decoder 336
                                             // 2728:     } else try {
  OPC_CheckPredicate, 35,                    // 2733:      check predicate 35
  OPC_Decode, 152, 29, 208, 2,               // 2735:      decode to VST2LNd32_UPD using decoder 336
                                             // 2735:     }
                                             // 2735:    }
                                             // 2735:    } // switch Inst[31:23]
                                             // 2735:   }
  2, 0,                                      // 2740:   case 0x2: {
  OPC_SwitchField, 23, 9,                    // 2742:    switch Inst[31:23] {
  232, 3, 67,                                // 2745:    case 0x1e8: {
  OPC_SwitchField, 7, 1,                     // 2748:     switch Inst[7] {
  0, 30,                                     // 2751:     case 0x0: {
  OPC_Scope, 21,                             // 2753:      try {
  OPC_SwitchField, 0, 4,                     // 2755:       switch Inst[3:0] {
  13, 7,                                     // 2758:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2760:        check predicate 35
  OPC_Decode, 153, 21, 213, 2,               // 2762:        decode to VLD2b8wb_fixed using decoder 341
                                             // 2762:       }
  15, 0,                                     // 2767:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2769:        check predicate 35
  OPC_Decode, 152, 21, 213, 2,               // 2771:        decode to VLD2b8 using decoder 341
                                             // 2771:       }
                                             // 2771:       } // switch Inst[3:0]
                                             // 2771:      } else try {
  OPC_CheckPredicate, 35,                    // 2776:       check predicate 35
  OPC_Decode, 154, 21, 213, 2,               // 2778:       decode to VLD2b8wb_register using decoder 341
                                             // 2778:      }
                                             // 2778:     }
  1, 0,                                      // 2783:     case 0x1: {
  OPC_Scope, 21,                             // 2785:      try {
  OPC_SwitchField, 0, 4,                     // 2787:       switch Inst[3:0] {
  13, 7,                                     // 2790:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 2792:        check predicate 35
  OPC_Decode, 150, 21, 213, 2,               // 2794:        decode to VLD2b32wb_fixed using decoder 341
                                             // 2794:       }
  15, 0,                                     // 2799:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 2801:        check predicate 35
  OPC_Decode, 149, 21, 213, 2,               // 2803:        decode to VLD2b32 using decoder 341
                                             // 2803:       }
                                             // 2803:       } // switch Inst[3:0]
                                             // 2803:      } else try {
  OPC_CheckPredicate, 35,                    // 2808:       check predicate 35
  OPC_Decode, 151, 21, 213, 2,               // 2810:       decode to VLD2b32wb_register using decoder 341
                                             // 2810:      }
                                             // 2810:     }
                                             // 2810:     } // switch Inst[7]
                                             // 2810:    }
  233, 3, 0,                                 // 2815:    case 0x1e9: {
  OPC_CheckField, 5, 1, 0,                   // 2818:     check Inst[5] == 0x0
  OPC_Scope, 11,                             // 2822:     try {
  OPC_CheckField, 0, 4, 15,                  // 2824:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 2828:      check predicate 35
  OPC_Decode, 130, 21, 209, 2,               // 2830:      decode to VLD2LNd32 using decoder 337
                                             // 2830:     } else try {
  OPC_CheckPredicate, 35,                    // 2835:      check predicate 35
  OPC_Decode, 133, 21, 209, 2,               // 2837:      decode to VLD2LNd32_UPD using decoder 337
                                             // 2837:     }
                                             // 2837:    }
                                             // 2837:    } // switch Inst[31:23]
                                             // 2837:   }
                                             // 2837:   } // switch Inst[21:20]
                                             // 2837:  }
  1, 0,                                      // 2842:  case 0x1: {
  OPC_SwitchField, 20, 2,                    // 2844:   switch Inst[21:20] {
  0, 67,                                     // 2847:   case 0x0: {
  OPC_SwitchField, 23, 9,                    // 2849:    switch Inst[31:23] {
  232, 3, 34,                                // 2852:    case 0x1e8: {
  OPC_CheckField, 7, 1, 0,                   // 2855:     check Inst[7] == 0x0
  OPC_Scope, 21,                             // 2859:     try {
  OPC_SwitchField, 0, 4,                     // 2861:      switch Inst[3:0] {
  13, 7,                                     // 2864:      case 0xd: {
  OPC_CheckPredicate, 35,                    // 2866:       check predicate 35
  OPC_Decode, 166, 29, 213, 2,               // 2868:       decode to VST2b16wb_fixed using decoder 341
                                             // 2868:      }
  15, 0,                                     // 2873:      case 0xf: {
  OPC_CheckPredicate, 35,                    // 2875:       check predicate 35
  OPC_Decode, 165, 29, 213, 2,               // 2877:       decode to VST2b16 using decoder 341
                                             // 2877:      }
                                             // 2877:      } // switch Inst[3:0]
                                             // 2877:     } else try {
  OPC_CheckPredicate, 35,                    // 2882:      check predicate 35
  OPC_Decode, 167, 29, 213, 2,               // 2884:      decode to VST2b16wb_register using decoder 341
                                             // 2884:     }
                                             // 2884:    }
  233, 3, 0,                                 // 2889:    case 0x1e9: {
  OPC_CheckField, 5, 1, 0,                   // 2892:     check Inst[5] == 0x0
  OPC_Scope, 11,                             // 2896:     try {
  OPC_CheckField, 0, 4, 15,                  // 2898:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 2902:      check predicate 35
  OPC_Decode, 161, 29, 208, 2,               // 2904:      decode to VST2LNq32 using decoder 336
                                             // 2904:     } else try {
  OPC_CheckPredicate, 35,                    // 2909:      check predicate 35
  OPC_Decode, 164, 29, 208, 2,               // 2911:      decode to VST2LNq32_UPD using decoder 336
                                             // 2911:     }
                                             // 2911:    }
                                             // 2911:    } // switch Inst[31:23]
                                             // 2911:   }
  2, 0,                                      // 2916:   case 0x2: {
  OPC_SwitchField, 23, 9,                    // 2918:    switch Inst[31:23] {
  232, 3, 34,                                // 2921:    case 0x1e8: {
  OPC_CheckField, 7, 1, 0,                   // 2924:     check Inst[7] == 0x0
  OPC_Scope, 21,                             // 2928:     try {
  OPC_SwitchField, 0, 4,                     // 2930:      switch Inst[3:0] {
  13, 7,                                     // 2933:      case 0xd: {
  OPC_CheckPredicate, 35,                    // 2935:       check predicate 35
  OPC_Decode, 147, 21, 213, 2,               // 2937:       decode to VLD2b16wb_fixed using decoder 341
                                             // 2937:      }
  15, 0,                                     // 2942:      case 0xf: {
  OPC_CheckPredicate, 35,                    // 2944:       check predicate 35
  OPC_Decode, 146, 21, 213, 2,               // 2946:       decode to VLD2b16 using decoder 341
                                             // 2946:      }
                                             // 2946:      } // switch Inst[3:0]
                                             // 2946:     } else try {
  OPC_CheckPredicate, 35,                    // 2951:      check predicate 35
  OPC_Decode, 148, 21, 213, 2,               // 2953:      decode to VLD2b16wb_register using decoder 341
                                             // 2953:     }
                                             // 2953:    }
  233, 3, 0,                                 // 2958:    case 0x1e9: {
  OPC_CheckField, 5, 1, 0,                   // 2961:     check Inst[5] == 0x0
  OPC_Scope, 11,                             // 2965:     try {
  OPC_CheckField, 0, 4, 15,                  // 2967:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 2971:      check predicate 35
  OPC_Decode, 142, 21, 209, 2,               // 2973:      decode to VLD2LNq32 using decoder 337
                                             // 2973:     } else try {
  OPC_CheckPredicate, 35,                    // 2978:      check predicate 35
  OPC_Decode, 145, 21, 209, 2,               // 2980:      decode to VLD2LNq32_UPD using decoder 337
                                             // 2980:     }
                                             // 2980:    }
                                             // 2980:    } // switch Inst[31:23]
                                             // 2980:   }
                                             // 2980:   } // switch Inst[21:20]
                                             // 2980:  }
                                             // 2980:  } // switch Inst[6]
                                             // 2980: }
  10, 166, 3,                                // 2985: case 0xa: {
  OPC_SwitchField, 6, 1,                     // 2988:  switch Inst[6] {
  0, 207, 1,                                 // 2991:  case 0x0: {
  OPC_SwitchField, 20, 2,                    // 2994:   switch Inst[21:20] {
  0, 100,                                    // 2997:   case 0x0: {
  OPC_SwitchField, 23, 9,                    // 2999:    switch Inst[31:23] {
  232, 3, 67,                                // 3002:    case 0x1e8: {
  OPC_SwitchField, 7, 1,                     // 3005:     switch Inst[7] {
  0, 30,                                     // 3008:     case 0x0: {
  OPC_Scope, 21,                             // 3010:      try {
  OPC_SwitchField, 0, 4,                     // 3012:       switch Inst[3:0] {
  13, 7,                                     // 3015:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 3017:        check predicate 35
  OPC_Decode, 143, 29, 210, 2,               // 3019:        decode to VST1q8wb_fixed using decoder 338
                                             // 3019:       }
  15, 0,                                     // 3024:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 3026:        check predicate 35
  OPC_Decode, 136, 29, 210, 2,               // 3028:        decode to VST1q8 using decoder 338
                                             // 3028:       }
                                             // 3028:       } // switch Inst[3:0]
                                             // 3028:      } else try {
  OPC_CheckPredicate, 35,                    // 3033:       check predicate 35
  OPC_Decode, 144, 29, 210, 2,               // 3035:       decode to VST1q8wb_register using decoder 338
                                             // 3035:      }
                                             // 3035:     }
  1, 0,                                      // 3040:     case 0x1: {
  OPC_Scope, 21,                             // 3042:      try {
  OPC_SwitchField, 0, 4,                     // 3044:       switch Inst[3:0] {
  13, 7,                                     // 3047:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 3049:        check predicate 35
  OPC_Decode, 253, 28, 210, 2,               // 3051:        decode to VST1q32wb_fixed using decoder 338
                                             // 3051:       }
  15, 0,                                     // 3056:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 3058:        check predicate 35
  OPC_Decode, 246, 28, 210, 2,               // 3060:        decode to VST1q32 using decoder 338
                                             // 3060:       }
                                             // 3060:       } // switch Inst[3:0]
                                             // 3060:      } else try {
  OPC_CheckPredicate, 35,                    // 3065:       check predicate 35
  OPC_Decode, 254, 28, 210, 2,               // 3067:       decode to VST1q32wb_register using decoder 338
                                             // 3067:      }
                                             // 3067:     }
                                             // 3067:     } // switch Inst[7]
                                             // 3067:    }
  233, 3, 0,                                 // 3072:    case 0x1e9: {
  OPC_CheckField, 4, 2, 0,                   // 3075:     check Inst[5:4] == 0x0
  OPC_Scope, 11,                             // 3079:     try {
  OPC_CheckField, 0, 4, 15,                  // 3081:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 3085:      check predicate 35
  OPC_Decode, 205, 29, 211, 2,               // 3087:      decode to VST3LNd32 using decoder 339
                                             // 3087:     } else try {
  OPC_CheckPredicate, 35,                    // 3092:      check predicate 35
  OPC_Decode, 208, 29, 211, 2,               // 3094:      decode to VST3LNd32_UPD using decoder 339
                                             // 3094:     }
                                             // 3094:    }
                                             // 3094:    } // switch Inst[31:23]
                                             // 3094:   }
  2, 0,                                      // 3099:   case 0x2: {
  OPC_SwitchField, 23, 9,                    // 3101:    switch Inst[31:23] {
  232, 3, 67,                                // 3104:    case 0x1e8: {
  OPC_SwitchField, 7, 1,                     // 3107:     switch Inst[7] {
  0, 30,                                     // 3110:     case 0x0: {
  OPC_Scope, 21,                             // 3112:      try {
  OPC_SwitchField, 0, 4,                     // 3114:       switch Inst[3:0] {
  13, 7,                                     // 3117:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 3119:        check predicate 35
  OPC_Decode, 222, 20, 210, 2,               // 3121:        decode to VLD1q8wb_fixed using decoder 338
                                             // 3121:       }
  15, 0,                                     // 3126:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 3128:        check predicate 35
  OPC_Decode, 215, 20, 210, 2,               // 3130:        decode to VLD1q8 using decoder 338
                                             // 3130:       }
                                             // 3130:       } // switch Inst[3:0]
                                             // 3130:      } else try {
  OPC_CheckPredicate, 35,                    // 3135:       check predicate 35
  OPC_Decode, 223, 20, 210, 2,               // 3137:       decode to VLD1q8wb_register using decoder 338
                                             // 3137:      }
                                             // 3137:     }
  1, 0,                                      // 3142:     case 0x1: {
  OPC_Scope, 21,                             // 3144:      try {
  OPC_SwitchField, 0, 4,                     // 3146:       switch Inst[3:0] {
  13, 7,                                     // 3149:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 3151:        check predicate 35
  OPC_Decode, 204, 20, 210, 2,               // 3153:        decode to VLD1q32wb_fixed using decoder 338
                                             // 3153:       }
  15, 0,                                     // 3158:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 3160:        check predicate 35
  OPC_Decode, 197, 20, 210, 2,               // 3162:        decode to VLD1q32 using decoder 338
                                             // 3162:       }
                                             // 3162:       } // switch Inst[3:0]
                                             // 3162:      } else try {
  OPC_CheckPredicate, 35,                    // 3167:       check predicate 35
  OPC_Decode, 205, 20, 210, 2,               // 3169:       decode to VLD1q32wb_register using decoder 338
                                             // 3169:      }
                                             // 3169:     }
                                             // 3169:     } // switch Inst[7]
                                             // 3169:    }
  233, 3, 0,                                 // 3174:    case 0x1e9: {
  OPC_CheckField, 4, 2, 0,                   // 3177:     check Inst[5:4] == 0x0
  OPC_Scope, 11,                             // 3181:     try {
  OPC_CheckField, 0, 4, 15,                  // 3183:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 3187:      check predicate 35
  OPC_Decode, 213, 21, 212, 2,               // 3189:      decode to VLD3LNd32 using decoder 340
                                             // 3189:     } else try {
  OPC_CheckPredicate, 35,                    // 3194:      check predicate 35
  OPC_Decode, 216, 21, 212, 2,               // 3196:      decode to VLD3LNd32_UPD using decoder 340
                                             // 3196:     }
                                             // 3196:    }
                                             // 3196:    } // switch Inst[31:23]
                                             // 3196:   }
                                             // 3196:   } // switch Inst[21:20]
                                             // 3196:  }
  1, 0,                                      // 3201:  case 0x1: {
  OPC_SwitchField, 20, 2,                    // 3203:   switch Inst[21:20] {
  0, 100,                                    // 3206:   case 0x0: {
  OPC_SwitchField, 23, 9,                    // 3208:    switch Inst[31:23] {
  232, 3, 67,                                // 3211:    case 0x1e8: {
  OPC_SwitchField, 7, 1,                     // 3214:     switch Inst[7] {
  0, 30,                                     // 3217:     case 0x0: {
  OPC_Scope, 21,                             // 3219:      try {
  OPC_SwitchField, 0, 4,                     // 3221:       switch Inst[3:0] {
  13, 7,                                     // 3224:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 3226:        check predicate 35
  OPC_Decode, 244, 28, 210, 2,               // 3228:        decode to VST1q16wb_fixed using decoder 338
                                             // 3228:       }
  15, 0,                                     // 3233:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 3235:        check predicate 35
  OPC_Decode, 237, 28, 210, 2,               // 3237:        decode to VST1q16 using decoder 338
                                             // 3237:       }
                                             // 3237:       } // switch Inst[3:0]
                                             // 3237:      } else try {
  OPC_CheckPredicate, 35,                    // 3242:       check predicate 35
  OPC_Decode, 245, 28, 210, 2,               // 3244:       decode to VST1q16wb_register using decoder 338
                                             // 3244:      }
                                             // 3244:     }
  1, 0,                                      // 3249:     case 0x1: {
  OPC_Scope, 21,                             // 3251:      try {
  OPC_SwitchField, 0, 4,                     // 3253:       switch Inst[3:0] {
  13, 7,                                     // 3256:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 3258:        check predicate 35
  OPC_Decode, 134, 29, 210, 2,               // 3260:        decode to VST1q64wb_fixed using decoder 338
                                             // 3260:       }
  15, 0,                                     // 3265:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 3267:        check predicate 35
  OPC_Decode, 255, 28, 210, 2,               // 3269:        decode to VST1q64 using decoder 338
                                             // 3269:       }
                                             // 3269:       } // switch Inst[3:0]
                                             // 3269:      } else try {
  OPC_CheckPredicate, 35,                    // 3274:       check predicate 35
  OPC_Decode, 135, 29, 210, 2,               // 3276:       decode to VST1q64wb_register using decoder 338
                                             // 3276:      }
                                             // 3276:     }
                                             // 3276:     } // switch Inst[7]
                                             // 3276:    }
  233, 3, 0,                                 // 3281:    case 0x1e9: {
  OPC_CheckField, 4, 2, 0,                   // 3284:     check Inst[5:4] == 0x0
  OPC_Scope, 11,                             // 3288:     try {
  OPC_CheckField, 0, 4, 15,                  // 3290:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 3294:      check predicate 35
  OPC_Decode, 217, 29, 211, 2,               // 3296:      decode to VST3LNq32 using decoder 339
                                             // 3296:     } else try {
  OPC_CheckPredicate, 35,                    // 3301:      check predicate 35
  OPC_Decode, 220, 29, 211, 2,               // 3303:      decode to VST3LNq32_UPD using decoder 339
                                             // 3303:     }
                                             // 3303:    }
                                             // 3303:    } // switch Inst[31:23]
                                             // 3303:   }
  2, 0,                                      // 3308:   case 0x2: {
  OPC_SwitchField, 23, 9,                    // 3310:    switch Inst[31:23] {
  232, 3, 67,                                // 3313:    case 0x1e8: {
  OPC_SwitchField, 7, 1,                     // 3316:     switch Inst[7] {
  0, 30,                                     // 3319:     case 0x0: {
  OPC_Scope, 21,                             // 3321:      try {
  OPC_SwitchField, 0, 4,                     // 3323:       switch Inst[3:0] {
  13, 7,                                     // 3326:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 3328:        check predicate 35
  OPC_Decode, 195, 20, 210, 2,               // 3330:        decode to VLD1q16wb_fixed using decoder 338
                                             // 3330:       }
  15, 0,                                     // 3335:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 3337:        check predicate 35
  OPC_Decode, 188, 20, 210, 2,               // 3339:        decode to VLD1q16 using decoder 338
                                             // 3339:       }
                                             // 3339:       } // switch Inst[3:0]
                                             // 3339:      } else try {
  OPC_CheckPredicate, 35,                    // 3344:       check predicate 35
  OPC_Decode, 196, 20, 210, 2,               // 3346:       decode to VLD1q16wb_register using decoder 338
                                             // 3346:      }
                                             // 3346:     }
  1, 0,                                      // 3351:     case 0x1: {
  OPC_Scope, 21,                             // 3353:      try {
  OPC_SwitchField, 0, 4,                     // 3355:       switch Inst[3:0] {
  13, 7,                                     // 3358:       case 0xd: {
  OPC_CheckPredicate, 35,                    // 3360:        check predicate 35
  OPC_Decode, 213, 20, 210, 2,               // 3362:        decode to VLD1q64wb_fixed using decoder 338
                                             // 3362:       }
  15, 0,                                     // 3367:       case 0xf: {
  OPC_CheckPredicate, 35,                    // 3369:        check predicate 35
  OPC_Decode, 206, 20, 210, 2,               // 3371:        decode to VLD1q64 using decoder 338
                                             // 3371:       }
                                             // 3371:       } // switch Inst[3:0]
                                             // 3371:      } else try {
  OPC_CheckPredicate, 35,                    // 3376:       check predicate 35
  OPC_Decode, 214, 20, 210, 2,               // 3378:       decode to VLD1q64wb_register using decoder 338
                                             // 3378:      }
                                             // 3378:     }
                                             // 3378:     } // switch Inst[7]
                                             // 3378:    }
  233, 3, 0,                                 // 3383:    case 0x1e9: {
  OPC_CheckField, 4, 2, 0,                   // 3386:     check Inst[5:4] == 0x0
  OPC_Scope, 11,                             // 3390:     try {
  OPC_CheckField, 0, 4, 15,                  // 3392:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 3396:      check predicate 35
  OPC_Decode, 225, 21, 212, 2,               // 3398:      decode to VLD3LNq32 using decoder 340
                                             // 3398:     } else try {
  OPC_CheckPredicate, 35,                    // 3403:      check predicate 35
  OPC_Decode, 228, 21, 212, 2,               // 3405:      decode to VLD3LNq32_UPD using decoder 340
                                             // 3405:     }
                                             // 3405:    }
                                             // 3405:    } // switch Inst[31:23]
                                             // 3405:   }
                                             // 3405:   } // switch Inst[21:20]
                                             // 3405:  }
                                             // 3405:  } // switch Inst[6]
                                             // 3405: }
  11, 121,                                   // 3410: case 0xb: {
  OPC_SwitchField, 6, 1,                     // 3412:  switch Inst[6] {
  0, 57,                                     // 3415:  case 0x0: {
  OPC_SwitchField, 20, 2,                    // 3417:   switch Inst[21:20] {
  0, 25,                                     // 3420:   case 0x0: {
  OPC_CheckField, 23, 9, 233, 3,             // 3422:    check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 3427:    try {
  OPC_CheckField, 0, 4, 15,                  // 3429:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 3433:     check predicate 35
  OPC_Decode, 252, 29, 214, 2,               // 3435:     decode to VST4LNd32 using decoder 342
                                             // 3435:    } else try {
  OPC_CheckPredicate, 35,                    // 3440:     check predicate 35
  OPC_Decode, 255, 29, 214, 2,               // 3442:     decode to VST4LNd32_UPD using decoder 342
                                             // 3442:    }
                                             // 3442:   }
  2, 0,                                      // 3447:   case 0x2: {
  OPC_CheckField, 23, 9, 233, 3,             // 3449:    check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 3454:    try {
  OPC_CheckField, 0, 4, 15,                  // 3456:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 3460:     check predicate 35
  OPC_Decode, 159, 22, 215, 2,               // 3462:     decode to VLD4LNd32 using decoder 343
                                             // 3462:    } else try {
  OPC_CheckPredicate, 35,                    // 3467:     check predicate 35
  OPC_Decode, 162, 22, 215, 2,               // 3469:     decode to VLD4LNd32_UPD using decoder 343
                                             // 3469:    }
                                             // 3469:   }
                                             // 3469:   } // switch Inst[21:20]
                                             // 3469:  }
  1, 0,                                      // 3474:  case 0x1: {
  OPC_SwitchField, 20, 2,                    // 3476:   switch Inst[21:20] {
  0, 25,                                     // 3479:   case 0x0: {
  OPC_CheckField, 23, 9, 233, 3,             // 3481:    check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 3486:    try {
  OPC_CheckField, 0, 4, 15,                  // 3488:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 3492:     check predicate 35
  OPC_Decode, 136, 30, 214, 2,               // 3494:     decode to VST4LNq32 using decoder 342
                                             // 3494:    } else try {
  OPC_CheckPredicate, 35,                    // 3499:     check predicate 35
  OPC_Decode, 139, 30, 214, 2,               // 3501:     decode to VST4LNq32_UPD using decoder 342
                                             // 3501:    }
                                             // 3501:   }
  2, 0,                                      // 3506:   case 0x2: {
  OPC_CheckField, 23, 9, 233, 3,             // 3508:    check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 3513:    try {
  OPC_CheckField, 0, 4, 15,                  // 3515:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 3519:     check predicate 35
  OPC_Decode, 171, 22, 215, 2,               // 3521:     decode to VLD4LNq32 using decoder 343
                                             // 3521:    } else try {
  OPC_CheckPredicate, 35,                    // 3526:     check predicate 35
  OPC_Decode, 174, 22, 215, 2,               // 3528:     decode to VLD4LNq32_UPD using decoder 343
                                             // 3528:    }
                                             // 3528:   }
                                             // 3528:   } // switch Inst[21:20]
                                             // 3528:  }
                                             // 3528:  } // switch Inst[6]
                                             // 3528: }
  12, 249, 1,                                // 3533: case 0xc: {
  OPC_SwitchField, 5, 3,                     // 3536:  switch Inst[7:5] {
  0, 39,                                     // 3539:  case 0x0: {
  OPC_CheckField, 20, 2, 2,                  // 3541:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 3545:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 3550:   try {
  OPC_SwitchField, 0, 4,                     // 3552:    switch Inst[3:0] {
  13, 7,                                     // 3555:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 3557:     check predicate 35
  OPC_Decode, 233, 19, 217, 2,               // 3559:     decode to VLD1DUPd8wb_fixed using decoder 345
                                             // 3559:    }
  15, 0,                                     // 3564:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 3566:     check predicate 35
  OPC_Decode, 232, 19, 217, 2,               // 3568:     decode to VLD1DUPd8 using decoder 345
                                             // 3568:    }
                                             // 3568:    } // switch Inst[3:0]
                                             // 3568:   } else try {
  OPC_CheckPredicate, 35,                    // 3573:    check predicate 35
  OPC_Decode, 234, 19, 217, 2,               // 3575:    decode to VLD1DUPd8wb_register using decoder 345
                                             // 3575:   }
                                             // 3575:  }
  1, 39,                                     // 3580:  case 0x1: {
  OPC_CheckField, 20, 2, 2,                  // 3582:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 3586:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 3591:   try {
  OPC_SwitchField, 0, 4,                     // 3593:    switch Inst[3:0] {
  13, 7,                                     // 3596:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 3598:     check predicate 35
  OPC_Decode, 242, 19, 217, 2,               // 3600:     decode to VLD1DUPq8wb_fixed using decoder 345
                                             // 3600:    }
  15, 0,                                     // 3605:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 3607:     check predicate 35
  OPC_Decode, 241, 19, 217, 2,               // 3609:     decode to VLD1DUPq8 using decoder 345
                                             // 3609:    }
                                             // 3609:    } // switch Inst[3:0]
                                             // 3609:   } else try {
  OPC_CheckPredicate, 35,                    // 3614:    check predicate 35
  OPC_Decode, 243, 19, 217, 2,               // 3616:    decode to VLD1DUPq8wb_register using decoder 345
                                             // 3616:   }
                                             // 3616:  }
  2, 39,                                     // 3621:  case 0x2: {
  OPC_CheckField, 20, 2, 2,                  // 3623:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 3627:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 3632:   try {
  OPC_SwitchField, 0, 4,                     // 3634:    switch Inst[3:0] {
  13, 7,                                     // 3637:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 3639:     check predicate 35
  OPC_Decode, 227, 19, 217, 2,               // 3641:     decode to VLD1DUPd16wb_fixed using decoder 345
                                             // 3641:    }
  15, 0,                                     // 3646:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 3648:     check predicate 35
  OPC_Decode, 226, 19, 217, 2,               // 3650:     decode to VLD1DUPd16 using decoder 345
                                             // 3650:    }
                                             // 3650:    } // switch Inst[3:0]
                                             // 3650:   } else try {
  OPC_CheckPredicate, 35,                    // 3655:    check predicate 35
  OPC_Decode, 228, 19, 217, 2,               // 3657:    decode to VLD1DUPd16wb_register using decoder 345
                                             // 3657:   }
                                             // 3657:  }
  3, 39,                                     // 3662:  case 0x3: {
  OPC_CheckField, 20, 2, 2,                  // 3664:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 3668:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 3673:   try {
  OPC_SwitchField, 0, 4,                     // 3675:    switch Inst[3:0] {
  13, 7,                                     // 3678:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 3680:     check predicate 35
  OPC_Decode, 236, 19, 217, 2,               // 3682:     decode to VLD1DUPq16wb_fixed using decoder 345
                                             // 3682:    }
  15, 0,                                     // 3687:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 3689:     check predicate 35
  OPC_Decode, 235, 19, 217, 2,               // 3691:     decode to VLD1DUPq16 using decoder 345
                                             // 3691:    }
                                             // 3691:    } // switch Inst[3:0]
                                             // 3691:   } else try {
  OPC_CheckPredicate, 35,                    // 3696:    check predicate 35
  OPC_Decode, 237, 19, 217, 2,               // 3698:    decode to VLD1DUPq16wb_register using decoder 345
                                             // 3698:   }
                                             // 3698:  }
  4, 39,                                     // 3703:  case 0x4: {
  OPC_CheckField, 20, 2, 2,                  // 3705:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 3709:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 3714:   try {
  OPC_SwitchField, 0, 4,                     // 3716:    switch Inst[3:0] {
  13, 7,                                     // 3719:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 3721:     check predicate 35
  OPC_Decode, 230, 19, 217, 2,               // 3723:     decode to VLD1DUPd32wb_fixed using decoder 345
                                             // 3723:    }
  15, 0,                                     // 3728:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 3730:     check predicate 35
  OPC_Decode, 229, 19, 217, 2,               // 3732:     decode to VLD1DUPd32 using decoder 345
                                             // 3732:    }
                                             // 3732:    } // switch Inst[3:0]
                                             // 3732:   } else try {
  OPC_CheckPredicate, 35,                    // 3737:    check predicate 35
  OPC_Decode, 231, 19, 217, 2,               // 3739:    decode to VLD1DUPd32wb_register using decoder 345
                                             // 3739:   }
                                             // 3739:  }
  5, 0,                                      // 3744:  case 0x5: {
  OPC_CheckField, 20, 2, 2,                  // 3746:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 3750:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 3755:   try {
  OPC_SwitchField, 0, 4,                     // 3757:    switch Inst[3:0] {
  13, 7,                                     // 3760:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 3762:     check predicate 35
  OPC_Decode, 239, 19, 217, 2,               // 3764:     decode to VLD1DUPq32wb_fixed using decoder 345
                                             // 3764:    }
  15, 0,                                     // 3769:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 3771:     check predicate 35
  OPC_Decode, 238, 19, 217, 2,               // 3773:     decode to VLD1DUPq32 using decoder 345
                                             // 3773:    }
                                             // 3773:    } // switch Inst[3:0]
                                             // 3773:   } else try {
  OPC_CheckPredicate, 35,                    // 3778:    check predicate 35
  OPC_Decode, 240, 19, 217, 2,               // 3780:    decode to VLD1DUPq32wb_register using decoder 345
                                             // 3780:   }
                                             // 3780:  }
                                             // 3780:  } // switch Inst[7:5]
                                             // 3780: }
  13, 249, 1,                                // 3785: case 0xd: {
  OPC_SwitchField, 5, 3,                     // 3788:  switch Inst[7:5] {
  0, 39,                                     // 3791:  case 0x0: {
  OPC_CheckField, 20, 2, 2,                  // 3793:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 3797:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 3802:   try {
  OPC_SwitchField, 0, 4,                     // 3804:    switch Inst[3:0] {
  13, 7,                                     // 3807:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 3809:     check predicate 35
  OPC_Decode, 237, 20, 218, 2,               // 3811:     decode to VLD2DUPd8wb_fixed using decoder 346
                                             // 3811:    }
  15, 0,                                     // 3816:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 3818:     check predicate 35
  OPC_Decode, 236, 20, 218, 2,               // 3820:     decode to VLD2DUPd8 using decoder 346
                                             // 3820:    }
                                             // 3820:    } // switch Inst[3:0]
                                             // 3820:   } else try {
  OPC_CheckPredicate, 35,                    // 3825:    check predicate 35
  OPC_Decode, 238, 20, 218, 2,               // 3827:    decode to VLD2DUPd8wb_register using decoder 346
                                             // 3827:   }
                                             // 3827:  }
  1, 39,                                     // 3832:  case 0x1: {
  OPC_CheckField, 20, 2, 2,                  // 3834:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 3838:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 3843:   try {
  OPC_SwitchField, 0, 4,                     // 3845:    switch Inst[3:0] {
  13, 7,                                     // 3848:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 3850:     check predicate 35
  OPC_Decode, 240, 20, 218, 2,               // 3852:     decode to VLD2DUPd8x2wb_fixed using decoder 346
                                             // 3852:    }
  15, 0,                                     // 3857:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 3859:     check predicate 35
  OPC_Decode, 239, 20, 218, 2,               // 3861:     decode to VLD2DUPd8x2 using decoder 346
                                             // 3861:    }
                                             // 3861:    } // switch Inst[3:0]
                                             // 3861:   } else try {
  OPC_CheckPredicate, 35,                    // 3866:    check predicate 35
  OPC_Decode, 241, 20, 218, 2,               // 3868:    decode to VLD2DUPd8x2wb_register using decoder 346
                                             // 3868:   }
                                             // 3868:  }
  2, 39,                                     // 3873:  case 0x2: {
  OPC_CheckField, 20, 2, 2,                  // 3875:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 3879:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 3884:   try {
  OPC_SwitchField, 0, 4,                     // 3886:    switch Inst[3:0] {
  13, 7,                                     // 3889:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 3891:     check predicate 35
  OPC_Decode, 225, 20, 218, 2,               // 3893:     decode to VLD2DUPd16wb_fixed using decoder 346
                                             // 3893:    }
  15, 0,                                     // 3898:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 3900:     check predicate 35
  OPC_Decode, 224, 20, 218, 2,               // 3902:     decode to VLD2DUPd16 using decoder 346
                                             // 3902:    }
                                             // 3902:    } // switch Inst[3:0]
                                             // 3902:   } else try {
  OPC_CheckPredicate, 35,                    // 3907:    check predicate 35
  OPC_Decode, 226, 20, 218, 2,               // 3909:    decode to VLD2DUPd16wb_register using decoder 346
                                             // 3909:   }
                                             // 3909:  }
  3, 39,                                     // 3914:  case 0x3: {
  OPC_CheckField, 20, 2, 2,                  // 3916:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 3920:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 3925:   try {
  OPC_SwitchField, 0, 4,                     // 3927:    switch Inst[3:0] {
  13, 7,                                     // 3930:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 3932:     check predicate 35
  OPC_Decode, 228, 20, 218, 2,               // 3934:     decode to VLD2DUPd16x2wb_fixed using decoder 346
                                             // 3934:    }
  15, 0,                                     // 3939:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 3941:     check predicate 35
  OPC_Decode, 227, 20, 218, 2,               // 3943:     decode to VLD2DUPd16x2 using decoder 346
                                             // 3943:    }
                                             // 3943:    } // switch Inst[3:0]
                                             // 3943:   } else try {
  OPC_CheckPredicate, 35,                    // 3948:    check predicate 35
  OPC_Decode, 229, 20, 218, 2,               // 3950:    decode to VLD2DUPd16x2wb_register using decoder 346
                                             // 3950:   }
                                             // 3950:  }
  4, 39,                                     // 3955:  case 0x4: {
  OPC_CheckField, 20, 2, 2,                  // 3957:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 3961:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 3966:   try {
  OPC_SwitchField, 0, 4,                     // 3968:    switch Inst[3:0] {
  13, 7,                                     // 3971:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 3973:     check predicate 35
  OPC_Decode, 231, 20, 218, 2,               // 3975:     decode to VLD2DUPd32wb_fixed using decoder 346
                                             // 3975:    }
  15, 0,                                     // 3980:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 3982:     check predicate 35
  OPC_Decode, 230, 20, 218, 2,               // 3984:     decode to VLD2DUPd32 using decoder 346
                                             // 3984:    }
                                             // 3984:    } // switch Inst[3:0]
                                             // 3984:   } else try {
  OPC_CheckPredicate, 35,                    // 3989:    check predicate 35
  OPC_Decode, 232, 20, 218, 2,               // 3991:    decode to VLD2DUPd32wb_register using decoder 346
                                             // 3991:   }
                                             // 3991:  }
  5, 0,                                      // 3996:  case 0x5: {
  OPC_CheckField, 20, 2, 2,                  // 3998:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4002:   check Inst[31:23] == 0x1e9
  OPC_Scope, 21,                             // 4007:   try {
  OPC_SwitchField, 0, 4,                     // 4009:    switch Inst[3:0] {
  13, 7,                                     // 4012:    case 0xd: {
  OPC_CheckPredicate, 35,                    // 4014:     check predicate 35
  OPC_Decode, 234, 20, 218, 2,               // 4016:     decode to VLD2DUPd32x2wb_fixed using decoder 346
                                             // 4016:    }
  15, 0,                                     // 4021:    case 0xf: {
  OPC_CheckPredicate, 35,                    // 4023:     check predicate 35
  OPC_Decode, 233, 20, 218, 2,               // 4025:     decode to VLD2DUPd32x2 using decoder 346
                                             // 4025:    }
                                             // 4025:    } // switch Inst[3:0]
                                             // 4025:   } else try {
  OPC_CheckPredicate, 35,                    // 4030:    check predicate 35
  OPC_Decode, 235, 20, 218, 2,               // 4032:    decode to VLD2DUPd32x2wb_register using decoder 346
                                             // 4032:   }
                                             // 4032:  }
                                             // 4032:  } // switch Inst[7:5]
                                             // 4032: }
  14, 189, 1,                                // 4037: case 0xe: {
  OPC_SwitchField, 4, 4,                     // 4040:  switch Inst[7:4] {
  0, 29,                                     // 4043:  case 0x0: {
  OPC_CheckField, 20, 2, 2,                  // 4045:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4049:   check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4054:   try {
  OPC_CheckField, 0, 4, 15,                  // 4056:    check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4060:    check predicate 35
  OPC_Decode, 190, 21, 219, 2,               // 4062:    decode to VLD3DUPd8 using decoder 347
                                             // 4062:   } else try {
  OPC_CheckPredicate, 35,                    // 4067:    check predicate 35
  OPC_Decode, 193, 21, 219, 2,               // 4069:    decode to VLD3DUPd8_UPD using decoder 347
                                             // 4069:   }
                                             // 4069:  }
  2, 29,                                     // 4074:  case 0x2: {
  OPC_CheckField, 20, 2, 2,                  // 4076:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4080:   check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4085:   try {
  OPC_CheckField, 0, 4, 15,                  // 4087:    check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4091:    check predicate 35
  OPC_Decode, 204, 21, 219, 2,               // 4093:    decode to VLD3DUPq8 using decoder 347
                                             // 4093:   } else try {
  OPC_CheckPredicate, 35,                    // 4098:    check predicate 35
  OPC_Decode, 208, 21, 219, 2,               // 4100:    decode to VLD3DUPq8_UPD using decoder 347
                                             // 4100:   }
                                             // 4100:  }
  4, 29,                                     // 4105:  case 0x4: {
  OPC_CheckField, 20, 2, 2,                  // 4107:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4111:   check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4116:   try {
  OPC_CheckField, 0, 4, 15,                  // 4118:    check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4122:    check predicate 35
  OPC_Decode, 182, 21, 219, 2,               // 4124:    decode to VLD3DUPd16 using decoder 347
                                             // 4124:   } else try {
  OPC_CheckPredicate, 35,                    // 4129:    check predicate 35
  OPC_Decode, 185, 21, 219, 2,               // 4131:    decode to VLD3DUPd16_UPD using decoder 347
                                             // 4131:   }
                                             // 4131:  }
  6, 29,                                     // 4136:  case 0x6: {
  OPC_CheckField, 20, 2, 2,                  // 4138:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4142:   check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4147:   try {
  OPC_CheckField, 0, 4, 15,                  // 4149:    check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4153:    check predicate 35
  OPC_Decode, 194, 21, 219, 2,               // 4155:    decode to VLD3DUPq16 using decoder 347
                                             // 4155:   } else try {
  OPC_CheckPredicate, 35,                    // 4160:    check predicate 35
  OPC_Decode, 198, 21, 219, 2,               // 4162:    decode to VLD3DUPq16_UPD using decoder 347
                                             // 4162:   }
                                             // 4162:  }
  8, 29,                                     // 4167:  case 0x8: {
  OPC_CheckField, 20, 2, 2,                  // 4169:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4173:   check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4178:   try {
  OPC_CheckField, 0, 4, 15,                  // 4180:    check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4184:    check predicate 35
  OPC_Decode, 186, 21, 219, 2,               // 4186:    decode to VLD3DUPd32 using decoder 347
                                             // 4186:   } else try {
  OPC_CheckPredicate, 35,                    // 4191:    check predicate 35
  OPC_Decode, 189, 21, 219, 2,               // 4193:    decode to VLD3DUPd32_UPD using decoder 347
                                             // 4193:   }
                                             // 4193:  }
  10, 0,                                     // 4198:  case 0xa: {
  OPC_CheckField, 20, 2, 2,                  // 4200:   check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4204:   check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4209:   try {
  OPC_CheckField, 0, 4, 15,                  // 4211:    check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4215:    check predicate 35
  OPC_Decode, 199, 21, 219, 2,               // 4217:    decode to VLD3DUPq32 using decoder 347
                                             // 4217:   } else try {
  OPC_CheckPredicate, 35,                    // 4222:    check predicate 35
  OPC_Decode, 203, 21, 219, 2,               // 4224:    decode to VLD3DUPq32_UPD using decoder 347
                                             // 4224:   }
                                             // 4224:  }
                                             // 4224:  } // switch Inst[7:4]
                                             // 4224: }
  15, 0,                                     // 4229: case 0xf: {
  OPC_SwitchField, 5, 1,                     // 4231:  switch Inst[5] {
  0, 101,                                    // 4234:  case 0x0: {
  OPC_SwitchField, 7, 1,                     // 4236:   switch Inst[7] {
  0, 65,                                     // 4239:   case 0x0: {
  OPC_SwitchField, 6, 1,                     // 4241:    switch Inst[6] {
  0, 29,                                     // 4244:    case 0x0: {
  OPC_CheckField, 20, 2, 2,                  // 4246:     check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4250:     check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4255:     try {
  OPC_CheckField, 0, 4, 15,                  // 4257:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4261:      check predicate 35
  OPC_Decode, 136, 22, 220, 2,               // 4263:      decode to VLD4DUPd8 using decoder 348
                                             // 4263:     } else try {
  OPC_CheckPredicate, 35,                    // 4268:      check predicate 35
  OPC_Decode, 139, 22, 220, 2,               // 4270:      decode to VLD4DUPd8_UPD using decoder 348
                                             // 4270:     }
                                             // 4270:    }
  1, 0,                                      // 4275:    case 0x1: {
  OPC_CheckField, 20, 2, 2,                  // 4277:     check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4281:     check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4286:     try {
  OPC_CheckField, 0, 4, 15,                  // 4288:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4292:      check predicate 35
  OPC_Decode, 128, 22, 220, 2,               // 4294:      decode to VLD4DUPd16 using decoder 348
                                             // 4294:     } else try {
  OPC_CheckPredicate, 35,                    // 4299:      check predicate 35
  OPC_Decode, 131, 22, 220, 2,               // 4301:      decode to VLD4DUPd16_UPD using decoder 348
                                             // 4301:     }
                                             // 4301:    }
                                             // 4301:    } // switch Inst[6]
                                             // 4301:   }
  1, 0,                                      // 4306:   case 0x1: {
  OPC_CheckField, 20, 2, 2,                  // 4308:    check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4312:    check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4317:    try {
  OPC_CheckField, 0, 4, 15,                  // 4319:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4323:     check predicate 35
  OPC_Decode, 132, 22, 220, 2,               // 4325:     decode to VLD4DUPd32 using decoder 348
                                             // 4325:    } else try {
  OPC_CheckPredicate, 35,                    // 4330:     check predicate 35
  OPC_Decode, 135, 22, 220, 2,               // 4332:     decode to VLD4DUPd32_UPD using decoder 348
                                             // 4332:    }
                                             // 4332:   }
                                             // 4332:   } // switch Inst[7]
                                             // 4332:  }
  1, 0,                                      // 4337:  case 0x1: {
  OPC_SwitchField, 7, 1,                     // 4339:   switch Inst[7] {
  0, 65,                                     // 4342:   case 0x0: {
  OPC_SwitchField, 6, 1,                     // 4344:    switch Inst[6] {
  0, 29,                                     // 4347:    case 0x0: {
  OPC_CheckField, 20, 2, 2,                  // 4349:     check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4353:     check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4358:     try {
  OPC_CheckField, 0, 4, 15,                  // 4360:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4364:      check predicate 35
  OPC_Decode, 150, 22, 220, 2,               // 4366:      decode to VLD4DUPq8 using decoder 348
                                             // 4366:     } else try {
  OPC_CheckPredicate, 35,                    // 4371:      check predicate 35
  OPC_Decode, 154, 22, 220, 2,               // 4373:      decode to VLD4DUPq8_UPD using decoder 348
                                             // 4373:     }
                                             // 4373:    }
  1, 0,                                      // 4378:    case 0x1: {
  OPC_CheckField, 20, 2, 2,                  // 4380:     check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4384:     check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4389:     try {
  OPC_CheckField, 0, 4, 15,                  // 4391:      check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4395:      check predicate 35
  OPC_Decode, 140, 22, 220, 2,               // 4397:      decode to VLD4DUPq16 using decoder 348
                                             // 4397:     } else try {
  OPC_CheckPredicate, 35,                    // 4402:      check predicate 35
  OPC_Decode, 144, 22, 220, 2,               // 4404:      decode to VLD4DUPq16_UPD using decoder 348
                                             // 4404:     }
                                             // 4404:    }
                                             // 4404:    } // switch Inst[6]
                                             // 4404:   }
  1, 0,                                      // 4409:   case 0x1: {
  OPC_CheckField, 20, 2, 2,                  // 4411:    check Inst[21:20] == 0x2
  OPC_CheckField, 23, 9, 233, 3,             // 4415:    check Inst[31:23] == 0x1e9
  OPC_Scope, 11,                             // 4420:    try {
  OPC_CheckField, 0, 4, 15,                  // 4422:     check Inst[3:0] == 0xf
  OPC_CheckPredicate, 35,                    // 4426:     check predicate 35
  OPC_Decode, 145, 22, 220, 2,               // 4428:     decode to VLD4DUPq32 using decoder 348
                                             // 4428:    } else try {
  OPC_CheckPredicate, 35,                    // 4433:     check predicate 35
  OPC_Decode, 149, 22, 220, 2,               // 4435:     decode to VLD4DUPq32_UPD using decoder 348
                                             // 4435:    }
                                             // 4435:   }
                                             // 4435:   } // switch Inst[7]
                                             // 4435:  }
                                             // 4435:  } // switch Inst[5]
                                             // 4435: }
                                             // 4435: } // switch Inst[11:8]
};
static const uint8_t DecoderTableThumb32[41] = {
  OPC_SwitchField, 12, 1,                    //  0: switch Inst[12] {
  0, 19,                                     //  3: case 0x0: {
  OPC_CheckPredicate, 44,                    //  5:  check predicate 44
  OPC_CheckField, 27, 5, 30,                 //  7:  check Inst[31:27] == 0x1e
  OPC_CheckField, 14, 2, 3,                  // 11:  check Inst[15:14] == 0x3
  OPC_CheckField, 0, 1, 0,                   // 15:  check Inst[0] == 0x0
  OPC_Decode, 225, 34, 221, 2,               // 19:  decode to tBLXi using decoder 349
                                             // 19: }
  1, 0,                                      // 24: case 0x1: {
  OPC_CheckPredicate, 0,                     // 26:  check predicate 0
  OPC_CheckField, 27, 5, 30,                 // 28:  check Inst[31:27] == 0x1e
  OPC_CheckField, 14, 2, 3,                  // 32:  check Inst[15:14] == 0x3
  OPC_Decode, 223, 34, 222, 2,               // 36:  decode to tBL using decoder 350
                                             // 36: }
                                             // 36: } // switch Inst[12]
};
static const uint8_t DecoderTableThumb232[5767] = {
  OPC_SwitchField, 27, 5,                    //    0: switch Inst[31:27] {
  29, 229, 11,                               //    3: case 0x1d: {
  OPC_SwitchField, 21, 2,                    //    6:  switch Inst[22:21] {
  0, 227, 2,                                 //    9:  case 0x0: {
  OPC_SwitchField, 23, 4,                    //   12:   switch Inst[26:23] {
  0, 33,                                     //   15:   case 0x0: {
  OPC_SwitchField, 20, 1,                    //   17:    switch Inst[20] {
  0, 13,                                     //   20:    case 0x0: {
  OPC_CheckPredicate, 45,                    //   22:     check predicate 45
  OPC_CheckField, 5, 15, 128, 220, 1,        //   24:     check Inst[19:5] == 0x6e00
  OPC_Decode, 213, 33, 223, 2,               //   30:     decode to t2SRSDB using decoder 351
                                             //   30:    }
  1, 0,                                      //   35:    case 0x1: {
  OPC_CheckPredicate, 45,                    //   37:     check predicate 45
  OPC_CheckField, 0, 16, 128, 128, 3,        //   39:     check Inst[15:0] == 0xc000
  OPC_Decode, 148, 33, 224, 2,               //   45:     decode to t2RFEDB using decoder 352
                                             //   45:    }
                                             //   45:    } // switch Inst[20]
                                             //   45:   }
  1, 46,                                     //   50:   case 0x1: {
  OPC_SwitchField, 20, 1,                    //   52:    switch Inst[20] {
  0, 15,                                     //   55:    case 0x0: {
  OPC_CheckPredicate, 9,                     //   57:     check predicate 9
  OPC_CheckField, 15, 1, 0,                  //   59:     check Inst[15] == 0x0
  OPC_CheckField, 13, 1, 0,                  //   63:     check Inst[13] == 0x0
  OPC_Decode, 247, 33, 225, 2,               //   67:     decode to t2STMIA using decoder 353
                                             //   67:    }
  1, 0,                                      //   72:    case 0x1: {
  OPC_Scope, 15,                             //   74:     try {
  OPC_CheckField, 13, 1, 0,                  //   76:      check Inst[13] == 0x0
  OPC_CheckPredicate, 46,                    //   80:      check predicate 46
  OPC_CheckField, 16, 4, 15,                 //   82:      check Inst[19:16] == 0xf
  OPC_Decode, 230, 31, 226, 2,               //   86:      decode to t2CLRM using decoder 354
                                             //   86:     } else try {
  OPC_CheckPredicate, 9,                     //   91:      check predicate 9
  OPC_Decode, 164, 32, 227, 2,               //   93:      decode to t2LDMIA using decoder 355
                                             //   93:     }
                                             //   93:    }
                                             //   93:    } // switch Inst[20]
                                             //   93:   }
  2, 29,                                     //   98:   case 0x2: {
  OPC_SwitchField, 20, 1,                    //  100:    switch Inst[20] {
  0, 15,                                     //  103:    case 0x0: {
  OPC_CheckPredicate, 9,                     //  105:     check predicate 9
  OPC_CheckField, 15, 1, 0,                  //  107:     check Inst[15] == 0x0
  OPC_CheckField, 13, 1, 0,                  //  111:     check Inst[13] == 0x0
  OPC_Decode, 245, 33, 225, 2,               //  115:     decode to t2STMDB using decoder 353
                                             //  115:    }
  1, 0,                                      //  120:    case 0x1: {
  OPC_CheckPredicate, 9,                     //  122:     check predicate 9
  OPC_Decode, 162, 32, 227, 2,               //  124:     decode to t2LDMDB using decoder 355
                                             //  124:    }
                                             //  124:    } // switch Inst[20]
                                             //  124:   }
  3, 33,                                     //  129:   case 0x3: {
  OPC_SwitchField, 20, 1,                    //  131:    switch Inst[20] {
  0, 13,                                     //  134:    case 0x0: {
  OPC_CheckPredicate, 45,                    //  136:     check predicate 45
  OPC_CheckField, 5, 15, 128, 220, 1,        //  138:     check Inst[19:5] == 0x6e00
  OPC_Decode, 215, 33, 223, 2,               //  144:     decode to t2SRSIA using decoder 351
                                             //  144:    }
  1, 0,                                      //  149:    case 0x1: {
  OPC_CheckPredicate, 45,                    //  151:     check predicate 45
  OPC_CheckField, 0, 16, 128, 128, 3,        //  153:     check Inst[15:0] == 0xc000
  OPC_Decode, 150, 33, 224, 2,               //  159:     decode to t2RFEIA using decoder 352
                                             //  159:    }
                                             //  159:    } // switch Inst[20]
                                             //  159:   }
  4, 69,                                     //  164:   case 0x4: {
  OPC_Scope, 16,                             //  166:    try {
  OPC_CheckField, 4, 11, 240, 1,             //  168:     check Inst[14:4] == 0xf0
  OPC_CheckPredicate, 9,                     //  173:     check predicate 9
  OPC_CheckField, 20, 1, 1,                  //  175:     check Inst[20] == 0x1
  OPC_Decode, 166, 34, 228, 2,               //  179:     decode to t2TSTrr using decoder 356
  OPC_Scope, 15,                             //  184:    } else try {
  OPC_CheckField, 20, 1, 1,                  //  186:     check Inst[20] == 0x1
  OPC_CheckPredicate, 9,                     //  190:     check predicate 9
  OPC_CheckField, 8, 4, 15,                  //  192:     check Inst[11:8] == 0xf
  OPC_Decode, 167, 34, 229, 2,               //  196:     decode to t2TSTrs using decoder 357
  OPC_Scope, 20,                             //  201:    } else try {
  OPC_CheckField, 4, 4, 0,                   //  203:     check Inst[7:4] == 0x0
  OPC_CheckPredicate, 9,                     //  207:     check predicate 9
  OPC_CheckField, 12, 3, 0,                  //  209:     check Inst[14:12] == 0x0
  OPC_SoftFail, 128, 128, 2, 0,              //  213:     softfail pos=0x00008000 neg=0x00000000
  OPC_Decode, 205, 31, 230, 2,               //  218:     decode to t2ANDrr using decoder 358
                                             //  218:    } else try {
  OPC_CheckPredicate, 9,                     //  223:     check predicate 9
  OPC_SoftFail, 128, 128, 2, 0,              //  225:     softfail pos=0x00008000 neg=0x00000000
  OPC_Decode, 206, 31, 231, 2,               //  230:     decode to t2ANDrs using decoder 359
                                             //  230:    }
                                             //  230:   }
  5, 69,                                     //  235:   case 0x5: {
  OPC_Scope, 16,                             //  237:    try {
  OPC_CheckField, 4, 11, 240, 1,             //  239:     check Inst[14:4] == 0xf0
  OPC_CheckPredicate, 9,                     //  244:     check predicate 9
  OPC_CheckField, 20, 1, 1,                  //  246:     check Inst[20] == 0x1
  OPC_Decode, 162, 34, 228, 2,               //  250:     decode to t2TEQrr using decoder 356
  OPC_Scope, 15,                             //  255:    } else try {
  OPC_CheckField, 20, 1, 1,                  //  257:     check Inst[20] == 0x1
  OPC_CheckPredicate, 9,                     //  261:     check predicate 9
  OPC_CheckField, 8, 4, 15,                  //  263:     check Inst[11:8] == 0xf
  OPC_Decode, 163, 34, 229, 2,               //  267:     decode to t2TEQrs using decoder 357
  OPC_Scope, 20,                             //  272:    } else try {
  OPC_CheckField, 4, 4, 0,                   //  274:     check Inst[7:4] == 0x0
  OPC_CheckPredicate, 9,                     //  278:     check predicate 9
  OPC_CheckField, 12, 3, 0,                  //  280:     check Inst[14:12] == 0x0
  OPC_SoftFail, 128, 128, 2, 0,              //  284:     softfail pos=0x00008000 neg=0x00000000
  OPC_Decode, 131, 32, 230, 2,               //  289:     decode to t2EORrr using decoder 358
                                             //  289:    } else try {
  OPC_CheckPredicate, 9,                     //  294:     check predicate 9
  OPC_SoftFail, 128, 128, 2, 0,              //  296:     softfail pos=0x00008000 neg=0x00000000
  OPC_Decode, 132, 32, 231, 2,               //  301:     decode to t2EORrs using decoder 359
                                             //  301:    }
                                             //  301:   }
  6, 0,                                      //  306:   case 0x6: {
  OPC_Scope, 16,                             //  308:    try {
  OPC_CheckField, 4, 11, 240, 1,             //  310:     check Inst[14:4] == 0xf0
  OPC_CheckPredicate, 9,                     //  315:     check predicate 9
  OPC_CheckField, 20, 1, 1,                  //  317:     check Inst[20] == 0x1
  OPC_Decode, 233, 31, 232, 2,               //  321:     decode to t2CMNzrr using decoder 360
  OPC_Scope, 15,                             //  326:    } else try {
  OPC_CheckField, 20, 1, 1,                  //  328:     check Inst[20] == 0x1
  OPC_CheckPredicate, 9,                     //  332:     check predicate 9
  OPC_CheckField, 8, 4, 15,                  //  334:     check Inst[11:8] == 0xf
  OPC_Decode, 234, 31, 233, 2,               //  338:     decode to t2CMNzrs using decoder 361
  OPC_Scope, 15,                             //  343:    } else try {
  OPC_CheckField, 4, 4, 0,                   //  345:     check Inst[7:4] == 0x0
  OPC_CheckPredicate, 9,                     //  349:     check predicate 9
  OPC_CheckField, 12, 3, 0,                  //  351:     check Inst[14:12] == 0x0
  OPC_Decode, 199, 31, 234, 2,               //  355:     decode to t2ADDrr using decoder 362
                                             //  355:    } else try {
  OPC_CheckPredicate, 9,                     //  360:     check predicate 9
  OPC_Decode, 200, 31, 235, 2,               //  362:     decode to t2ADDrs using decoder 363
                                             //  362:    }
                                             //  362:   }
                                             //  362:   } // switch Inst[26:23]
                                             //  362:  }
  1, 232, 1,                                 //  367:  case 0x1: {
  OPC_SwitchField, 23, 4,                    //  370:   switch Inst[26:23] {
  0, 33,                                     //  373:   case 0x0: {
  OPC_SwitchField, 20, 1,                    //  375:    switch Inst[20] {
  0, 13,                                     //  378:    case 0x0: {
  OPC_CheckPredicate, 45,                    //  380:     check predicate 45
  OPC_CheckField, 5, 15, 128, 220, 1,        //  382:     check Inst[19:5] == 0x6e00
  OPC_Decode, 214, 33, 223, 2,               //  388:     decode to t2SRSDB_UPD using decoder 351
                                             //  388:    }
  1, 0,                                      //  393:    case 0x1: {
  OPC_CheckPredicate, 45,                    //  395:     check predicate 45
  OPC_CheckField, 0, 16, 128, 128, 3,        //  397:     check Inst[15:0] == 0xc000
  OPC_Decode, 149, 33, 224, 2,               //  403:     decode to t2RFEDBW using decoder 352
                                             //  403:    }
                                             //  403:    } // switch Inst[20]
                                             //  403:   }
  1, 29,                                     //  408:   case 0x1: {
  OPC_SwitchField, 20, 1,                    //  410:    switch Inst[20] {
  0, 15,                                     //  413:    case 0x0: {
  OPC_CheckPredicate, 9,                     //  415:     check predicate 9
  OPC_CheckField, 15, 1, 0,                  //  417:     check Inst[15] == 0x0
  OPC_CheckField, 13, 1, 0,                  //  421:     check Inst[13] == 0x0
  OPC_Decode, 248, 33, 236, 2,               //  425:     decode to t2STMIA_UPD using decoder 364
                                             //  425:    }
  1, 0,                                      //  430:    case 0x1: {
  OPC_CheckPredicate, 9,                     //  432:     check predicate 9
  OPC_Decode, 165, 32, 237, 2,               //  434:     decode to t2LDMIA_UPD using decoder 365
                                             //  434:    }
                                             //  434:    } // switch Inst[20]
                                             //  434:   }
  2, 29,                                     //  439:   case 0x2: {
  OPC_SwitchField, 20, 1,                    //  441:    switch Inst[20] {
  0, 15,                                     //  444:    case 0x0: {
  OPC_CheckPredicate, 9,                     //  446:     check predicate 9
  OPC_CheckField, 15, 1, 0,                  //  448:     check Inst[15] == 0x0
  OPC_CheckField, 13, 1, 0,                  //  452:     check Inst[13] == 0x0
  OPC_Decode, 246, 33, 236, 2,               //  456:     decode to t2STMDB_UPD using decoder 364
                                             //  456:    }
  1, 0,                                      //  461:    case 0x1: {
  OPC_CheckPredicate, 9,                     //  463:     check predicate 9
  OPC_Decode, 163, 32, 237, 2,               //  465:     decode to t2LDMDB_UPD using decoder 365
                                             //  465:    }
                                             //  465:    } // switch Inst[20]
                                             //  465:   }
  3, 33,                                     //  470:   case 0x3: {
  OPC_SwitchField, 20, 1,                    //  472:    switch Inst[20] {
  0, 13,                                     //  475:    case 0x0: {
  OPC_CheckPredicate, 45,                    //  477:     check predicate 45
  OPC_CheckField, 5, 15, 128, 220, 1,        //  479:     check Inst[19:5] == 0x6e00
  OPC_Decode, 216, 33, 223, 2,               //  485:     decode to t2SRSIA_UPD using decoder 351
                                             //  485:    }
  1, 0,                                      //  490:    case 0x1: {
  OPC_CheckPredicate, 45,                    //  492:     check predicate 45
  OPC_CheckField, 0, 16, 128, 128, 3,        //  494:     check Inst[15:0] == 0xc000
  OPC_Decode, 151, 33, 224, 2,               //  500:     decode to t2RFEIAW using decoder 352
                                             //  500:    }
                                             //  500:    } // switch Inst[20]
                                             //  500:   }
  4, 34,                                     //  505:   case 0x4: {
  OPC_Scope, 20,                             //  507:    try {
  OPC_CheckField, 4, 4, 0,                   //  509:     check Inst[7:4] == 0x0
  OPC_CheckPredicate, 9,                     //  513:     check predicate 9
  OPC_CheckField, 12, 3, 0,                  //  515:     check Inst[14:12] == 0x0
  OPC_SoftFail, 128, 128, 2, 0,              //  519:     softfail pos=0x00008000 neg=0x00000000
  OPC_Decode, 221, 31, 230, 2,               //  524:     decode to t2BICrr using decoder 358
                                             //  524:    } else try {
  OPC_CheckPredicate, 9,                     //  529:     check predicate 9
  OPC_SoftFail, 128, 128, 2, 0,              //  531:     softfail pos=0x00008000 neg=0x00000000
  OPC_Decode, 222, 31, 231, 2,               //  536:     decode to t2BICrs using decoder 359
                                             //  536:    }
                                             //  536:   }
  7, 0,                                      //  541:   case 0x7: {
  OPC_Scope, 16,                             //  543:    try {
  OPC_CheckField, 4, 11, 240, 1,             //  545:     check Inst[14:4] == 0xf0
  OPC_CheckPredicate, 9,                     //  550:     check predicate 9
  OPC_CheckField, 20, 1, 1,                  //  552:     check Inst[20] == 0x1
  OPC_Decode, 236, 31, 232, 2,               //  556:     decode to t2CMPrr using decoder 360
  OPC_Scope, 15,                             //  561:    } else try {
  OPC_CheckField, 20, 1, 1,                  //  563:     check Inst[20] == 0x1
  OPC_CheckPredicate, 9,                     //  567:     check predicate 9
  OPC_CheckField, 8, 4, 15,                  //  569:     check Inst[11:8] == 0xf
  OPC_Decode, 237, 31, 233, 2,               //  573:     decode to t2CMPrs using decoder 361
  OPC_Scope, 15,                             //  578:    } else try {
  OPC_CheckField, 4, 4, 0,                   //  580:     check Inst[7:4] == 0x0
  OPC_CheckPredicate, 9,                     //  584:     check predicate 9
  OPC_CheckField, 12, 3, 0,                  //  586:     check Inst[14:12] == 0x0
  OPC_Decode, 149, 34, 234, 2,               //  590:     decode to t2SUBrr using decoder 362
                                             //  590:    } else try {
  OPC_CheckPredicate, 9,                     //  595:     check predicate 9
  OPC_Decode, 150, 34, 235, 2,               //  597:     decode to t2SUBrs using decoder 363
                                             //  597:    }
                                             //  597:   }
                                             //  597:   } // switch Inst[26:23]
                                             //  597:  }
  2, 232, 5,                                 //  602:  case 0x2: {
  OPC_SwitchField, 24, 3,                    //  605:   switch Inst[26:24] {
  0, 183, 3,                                 //  608:   case 0x0: {
  OPC_SwitchField, 20, 1,                    //  611:    switch Inst[20] {
  0, 220, 1,                                 //  614:    case 0x0: {
  OPC_SwitchField, 23, 1,                    //  617:     switch Inst[23] {
  0, 76,                                     //  620:     case 0x0: {
  OPC_Scope, 67,                             //  622:      try {
  OPC_SwitchField, 6, 2,                     //  624:       switch Inst[7:6] {
  0, 14,                                     //  627:       case 0x0: {
  OPC_CheckPredicate, 1,                     //  629:        check predicate 1
  OPC_CheckField, 12, 4, 15,                 //  631:        check Inst[15:12] == 0xf
  OPC_SoftFail, 63, 0,                       //  635:        softfail pos=0x0000003f neg=0x00000000
  OPC_Decode, 168, 34, 238, 2,               //  638:        decode to t2TT using decoder 366
                                             //  638:       }
  1, 14,                                     //  643:       case 0x1: {
  OPC_CheckPredicate, 1,                     //  645:        check predicate 1
  OPC_CheckField, 12, 4, 15,                 //  647:        check Inst[15:12] == 0xf
  OPC_SoftFail, 63, 0,                       //  651:        softfail pos=0x0000003f neg=0x00000000
  OPC_Decode, 171, 34, 238, 2,               //  654:        decode to t2TTT using decoder 366
                                             //  654:       }
  2, 14,                                     //  659:       case 0x2: {
  OPC_CheckPredicate, 1,                     //  661:        check predicate 1
  OPC_CheckField, 12, 4, 15,                 //  663:        check Inst[15:12] == 0xf
  OPC_SoftFail, 63, 0,                       //  667:        softfail pos=0x0000003f neg=0x00000000
  OPC_Decode, 169, 34, 238, 2,               //  670:        decode to t2TTA using decoder 366
                                             //  670:       }
  3, 0,                                      //  675:       case 0x3: {
  OPC_CheckPredicate, 1,                     //  677:        check predicate 1
  OPC_CheckField, 12, 4, 15,                 //  679:        check Inst[15:12] == 0xf
  OPC_SoftFail, 63, 0,                       //  683:        softfail pos=0x0000003f neg=0x00000000
  OPC_Decode, 170, 34, 238, 2,               //  686:        decode to t2TTAT using decoder 366
                                             //  686:       }
                                             //  686:       } // switch Inst[7:6]
                                             //  686:      } else try {
  OPC_CheckPredicate, 4,                     //  691:       check predicate 4
  OPC_Decode, 130, 34, 239, 2,               //  693:       decode to t2STREX using decoder 367
                                             //  693:      }
                                             //  693:     }
  1, 0,                                      //  698:     case 0x1: {
  OPC_SwitchField, 4, 4,                     //  700:      switch Inst[7:4] {
  4, 11,                                     //  703:      case 0x4: {
  OPC_CheckPredicate, 4,                     //  705:       check predicate 4
  OPC_CheckField, 8, 4, 15,                  //  707:       check Inst[11:8] == 0xf
  OPC_Decode, 131, 34, 240, 2,               //  711:       decode to t2STREXB using decoder 368
                                             //  711:      }
  5, 11,                                     //  716:      case 0x5: {
  OPC_CheckPredicate, 4,                     //  718:       check predicate 4
  OPC_CheckField, 8, 4, 15,                  //  720:       check Inst[11:8] == 0xf
  OPC_Decode, 133, 34, 240, 2,               //  724:       decode to t2STREXH using decoder 368
                                             //  724:      }
  7, 7,                                      //  729:      case 0x7: {
  OPC_CheckPredicate, 45,                    //  731:       check predicate 45
  OPC_Decode, 132, 34, 241, 2,               //  733:       decode to t2STREXD using decoder 369
                                             //  733:      }
  8, 15,                                     //  738:      case 0x8: {
  OPC_CheckPredicate, 47,                    //  740:       check predicate 47
  OPC_CheckField, 8, 4, 15,                  //  742:       check Inst[11:8] == 0xf
  OPC_CheckField, 0, 4, 15,                  //  746:       check Inst[3:0] == 0xf
  OPC_Decode, 239, 33, 242, 2,               //  750:       decode to t2STLB using decoder 370
                                             //  750:      }
  9, 15,                                     //  755:      case 0x9: {
  OPC_CheckPredicate, 47,                    //  757:       check predicate 47
  OPC_CheckField, 8, 4, 15,                  //  759:       check Inst[11:8] == 0xf
  OPC_CheckField, 0, 4, 15,                  //  763:       check Inst[3:0] == 0xf
  OPC_Decode, 244, 33, 242, 2,               //  767:       decode to t2STLH using decoder 370
                                             //  767:      }
  10, 15,                                    //  772:      case 0xa: {
  OPC_CheckPredicate, 47,                    //  774:       check predicate 47
  OPC_CheckField, 8, 4, 15,                  //  776:       check Inst[11:8] == 0xf
  OPC_CheckField, 0, 4, 15,                  //  780:       check Inst[3:0] == 0xf
  OPC_Decode, 238, 33, 242, 2,               //  784:       decode to t2STL using decoder 370
                                             //  784:      }
  12, 11,                                    //  789:      case 0xc: {
  OPC_CheckPredicate, 48,                    //  791:       check predicate 48
  OPC_CheckField, 8, 4, 15,                  //  793:       check Inst[11:8] == 0xf
  OPC_Decode, 241, 33, 240, 2,               //  797:       decode to t2STLEXB using decoder 368
                                             //  797:      }
  13, 11,                                    //  802:      case 0xd: {
  OPC_CheckPredicate, 48,                    //  804:       check predicate 48
  OPC_CheckField, 8, 4, 15,                  //  806:       check Inst[11:8] == 0xf
  OPC_Decode, 243, 33, 240, 2,               //  810:       decode to t2STLEXH using decoder 368
                                             //  810:      }
  14, 11,                                    //  815:      case 0xe: {
  OPC_CheckPredicate, 48,                    //  817:       check predicate 48
  OPC_CheckField, 8, 4, 15,                  //  819:       check Inst[11:8] == 0xf
  OPC_Decode, 240, 33, 240, 2,               //  823:       decode to t2STLEX using decoder 368
                                             //  823:      }
  15, 0,                                     //  828:      case 0xf: {
  OPC_CheckPredicate, 49,                    //  830:       check predicate 49
  OPC_Decode, 242, 33, 241, 2,               //  832:       decode to t2STLEXD using decoder 369
                                             //  832:      }
                                             //  832:      } // switch Inst[7:4]
                                             //  832:     }
                                             //  832:     } // switch Inst[23]
                                             //  832:    }
  1, 0,                                      //  837:    case 0x1: {
  OPC_SwitchField, 23, 1,                    //  839:     switch Inst[23] {
  0, 11,                                     //  842:     case 0x0: {
  OPC_CheckPredicate, 4,                     //  844:      check predicate 4
  OPC_CheckField, 8, 4, 15,                  //  846:      check Inst[11:8] == 0xf
  OPC_Decode, 176, 32, 243, 2,               //  850:      decode to t2LDREX using decoder 371
                                             //  850:     }
  1, 0,                                      //  855:     case 0x1: {
  OPC_SwitchField, 4, 4,                     //  857:      switch Inst[7:4] {
  0, 12,                                     //  860:      case 0x0: {
  OPC_CheckPredicate, 9,                     //  862:       check predicate 9
  OPC_CheckField, 8, 8, 240, 1,              //  864:       check Inst[15:8] == 0xf0
  OPC_Decode, 159, 34, 244, 2,               //  869:       decode to t2TBB using decoder 372
                                             //  869:      }
  1, 12,                                     //  874:      case 0x1: {
  OPC_CheckPredicate, 9,                     //  876:       check predicate 9
  OPC_CheckField, 8, 8, 240, 1,              //  878:       check Inst[15:8] == 0xf0
  OPC_Decode, 160, 34, 244, 2,               //  883:       decode to t2TBH using decoder 372
                                             //  883:      }
  4, 15,                                     //  888:      case 0x4: {
  OPC_CheckPredicate, 4,                     //  890:       check predicate 4
  OPC_CheckField, 8, 4, 15,                  //  892:       check Inst[11:8] == 0xf
  OPC_CheckField, 0, 4, 15,                  //  896:       check Inst[3:0] == 0xf
  OPC_Decode, 177, 32, 242, 2,               //  900:       decode to t2LDREXB using decoder 370
                                             //  900:      }
  5, 15,                                     //  905:      case 0x5: {
  OPC_CheckPredicate, 4,                     //  907:       check predicate 4
  OPC_CheckField, 8, 4, 15,                  //  909:       check Inst[11:8] == 0xf
  OPC_CheckField, 0, 4, 15,                  //  913:       check Inst[3:0] == 0xf
  OPC_Decode, 179, 32, 242, 2,               //  917:       decode to t2LDREXH using decoder 370
                                             //  917:      }
  7, 11,                                     //  922:      case 0x7: {
  OPC_CheckPredicate, 45,                    //  924:       check predicate 45
  OPC_CheckField, 0, 4, 15,                  //  926:       check Inst[3:0] == 0xf
  OPC_Decode, 178, 32, 245, 2,               //  930:       decode to t2LDREXD using decoder 373
                                             //  930:      }
  8, 15,                                     //  935:      case 0x8: {
  OPC_CheckPredicate, 47,                    //  937:       check predicate 47
  OPC_CheckField, 8, 4, 15,                  //  939:       check Inst[11:8] == 0xf
  OPC_CheckField, 0, 4, 15,                  //  943:       check Inst[3:0] == 0xf
  OPC_Decode, 140, 32, 242, 2,               //  947:       decode to t2LDAB using decoder 370
                                             //  947:      }
  9, 15,                                     //  952:      case 0x9: {
  OPC_CheckPredicate, 47,                    //  954:       check predicate 47
  OPC_CheckField, 8, 4, 15,                  //  956:       check Inst[11:8] == 0xf
  OPC_CheckField, 0, 4, 15,                  //  960:       check Inst[3:0] == 0xf
  OPC_Decode, 145, 32, 242, 2,               //  964:       decode to t2LDAH using decoder 370
                                             //  964:      }
  10, 15,                                    //  969:      case 0xa: {
  OPC_CheckPredicate, 47,                    //  971:       check predicate 47
  OPC_CheckField, 8, 4, 15,                  //  973:       check Inst[11:8] == 0xf
  OPC_CheckField, 0, 4, 15,                  //  977:       check Inst[3:0] == 0xf
  OPC_Decode, 139, 32, 242, 2,               //  981:       decode to t2LDA using decoder 370
                                             //  981:      }
  12, 15,                                    //  986:      case 0xc: {
  OPC_CheckPredicate, 48,                    //  988:       check predicate 48
  OPC_CheckField, 8, 4, 15,                  //  990:       check Inst[11:8] == 0xf
  OPC_CheckField, 0, 4, 15,                  //  994:       check Inst[3:0] == 0xf
  OPC_Decode, 142, 32, 242, 2,               //  998:       decode to t2LDAEXB using decoder 370
                                             //  998:      }
  13, 15,                                    // 1003:      case 0xd: {
  OPC_CheckPredicate, 48,                    // 1005:       check predicate 48
  OPC_CheckField, 8, 4, 15,                  // 1007:       check Inst[11:8] == 0xf
  OPC_CheckField, 0, 4, 15,                  // 1011:       check Inst[3:0] == 0xf
  OPC_Decode, 144, 32, 242, 2,               // 1015:       decode to t2LDAEXH using decoder 370
                                             // 1015:      }
  14, 15,                                    // 1020:      case 0xe: {
  OPC_CheckPredicate, 48,                    // 1022:       check predicate 48
  OPC_CheckField, 8, 4, 15,                  // 1024:       check Inst[11:8] == 0xf
  OPC_CheckField, 0, 4, 15,                  // 1028:       check Inst[3:0] == 0xf
  OPC_Decode, 141, 32, 242, 2,               // 1032:       decode to t2LDAEX using decoder 370
                                             // 1032:      }
  15, 0,                                     // 1037:      case 0xf: {
  OPC_CheckPredicate, 49,                    // 1039:       check predicate 49
  OPC_CheckField, 0, 4, 15,                  // 1041:       check Inst[3:0] == 0xf
  OPC_Decode, 143, 32, 245, 2,               // 1045:       decode to t2LDAEXD using decoder 373
                                             // 1045:      }
                                             // 1045:      } // switch Inst[7:4]
                                             // 1045:     }
                                             // 1045:     } // switch Inst[23]
                                             // 1045:    }
                                             // 1045:    } // switch Inst[20]
                                             // 1045:   }
  1, 21,                                     // 1050:   case 0x1: {
  OPC_SwitchField, 20, 1,                    // 1052:    switch Inst[20] {
  0, 7,                                      // 1055:    case 0x0: {
  OPC_CheckPredicate, 9,                     // 1057:     check predicate 9
  OPC_Decode, 129, 34, 246, 2,               // 1059:     decode to t2STRDi8 using decoder 374
                                             // 1059:    }
  1, 0,                                      // 1064:    case 0x1: {
  OPC_CheckPredicate, 9,                     // 1066:     check predicate 9
  OPC_Decode, 175, 32, 246, 2,               // 1068:     decode to t2LDRDi8 using decoder 374
                                             // 1068:    }
                                             // 1068:    } // switch Inst[20]
                                             // 1068:   }
  2, 216, 1,                                 // 1073:   case 0x2: {
  OPC_SwitchField, 23, 1,                    // 1076:    switch Inst[23] {
  0, 179, 1,                                 // 1079:    case 0x0: {
  OPC_Scope, 51,                             // 1082:     try {
  OPC_SwitchField, 4, 4,                     // 1084:      switch Inst[7:4] {
  0, 24,                                     // 1087:      case 0x0: {
  OPC_CheckField, 12, 4, 0,                  // 1089:       check Inst[15:12] == 0x0
  OPC_Scope, 11,                             // 1093:       try {
  OPC_CheckField, 16, 4, 15,                 // 1095:        check Inst[19:16] == 0xf
  OPC_CheckPredicate, 9,                     // 1099:        check predicate 9
  OPC_Decode, 224, 32, 247, 2,               // 1101:        decode to t2MOVr using decoder 375
                                             // 1101:       } else try {
  OPC_CheckPredicate, 9,                     // 1106:        check predicate 9
  OPC_Decode, 244, 32, 230, 2,               // 1108:        decode to t2ORRrr using decoder 358
                                             // 1108:       }
                                             // 1108:      }
  3, 0,                                      // 1113:      case 0x3: {
  OPC_CheckPredicate, 9,                     // 1115:       check predicate 9
  OPC_CheckField, 16, 4, 15,                 // 1117:       check Inst[19:16] == 0xf
  OPC_CheckField, 12, 3, 0,                  // 1121:       check Inst[14:12] == 0x0
  OPC_SoftFail, 128, 128, 2, 0,              // 1125:       softfail pos=0x00008000 neg=0x00000000
  OPC_Decode, 154, 33, 248, 2,               // 1130:       decode to t2RRX using decoder 376
                                             // 1130:      }
                                             // 1130:      } // switch Inst[7:4]
                                             // 1130:     } else try {
  OPC_SwitchField, 15, 1,                    // 1135:      switch Inst[15] {
  0, 64,                                     // 1138:      case 0x0: {
  OPC_Scope, 55,                             // 1140:       try {
  OPC_SwitchField, 4, 2,                     // 1142:        switch Inst[5:4] {
  0, 11,                                     // 1145:        case 0x0: {
  OPC_CheckPredicate, 9,                     // 1147:         check predicate 9
  OPC_CheckField, 16, 4, 15,                 // 1149:         check Inst[19:16] == 0xf
  OPC_Decode, 210, 32, 249, 2,               // 1153:         decode to t2LSLri using decoder 377
                                             // 1153:        }
  1, 11,                                     // 1158:        case 0x1: {
  OPC_CheckPredicate, 9,                     // 1160:         check predicate 9
  OPC_CheckField, 16, 4, 15,                 // 1162:         check Inst[19:16] == 0xf
  OPC_Decode, 212, 32, 249, 2,               // 1166:         decode to t2LSRri using decoder 377
                                             // 1166:        }
  2, 11,                                     // 1171:        case 0x2: {
  OPC_CheckPredicate, 9,                     // 1173:         check predicate 9
  OPC_CheckField, 16, 4, 15,                 // 1175:         check Inst[19:16] == 0xf
  OPC_Decode, 207, 31, 249, 2,               // 1179:         decode to t2ASRri using decoder 377
                                             // 1179:        }
  3, 0,                                      // 1184:        case 0x3: {
  OPC_CheckPredicate, 9,                     // 1186:         check predicate 9
  OPC_CheckField, 16, 4, 15,                 // 1188:         check Inst[19:16] == 0xf
  OPC_Decode, 152, 33, 249, 2,               // 1192:         decode to t2RORri using decoder 377
                                             // 1192:        }
                                             // 1192:        } // switch Inst[5:4]
                                             // 1192:       } else try {
  OPC_CheckPredicate, 9,                     // 1197:        check predicate 9
  OPC_Decode, 245, 32, 231, 2,               // 1199:        decode to t2ORRrs using decoder 359
                                             // 1199:       }
                                             // 1199:      }
  1, 0,                                      // 1204:      case 0x1: {
  OPC_SwitchField, 12, 3,                    // 1206:       switch Inst[14:12] {
  0, 11,                                     // 1209:       case 0x0: {
  OPC_CheckPredicate, 46,                    // 1211:        check predicate 46
  OPC_CheckField, 20, 1, 1,                  // 1213:        check Inst[20] == 0x1
  OPC_Decode, 247, 31, 250, 2,               // 1217:        decode to t2CSEL using decoder 378
                                             // 1217:       }
  1, 11,                                     // 1222:       case 0x1: {
  OPC_CheckPredicate, 46,                    // 1224:        check predicate 46
  OPC_CheckField, 20, 1, 1,                  // 1226:        check Inst[20] == 0x1
  OPC_Decode, 248, 31, 250, 2,               // 1230:        decode to t2CSINC using decoder 378
                                             // 1230:       }
  2, 11,                                     // 1235:       case 0x2: {
  OPC_CheckPredicate, 46,                    // 1237:        check predicate 46
  OPC_CheckField, 20, 1, 1,                  // 1239:        check Inst[20] == 0x1
  OPC_Decode, 249, 31, 250, 2,               // 1243:        decode to t2CSINV using decoder 378
                                             // 1243:       }
  3, 0,                                      // 1248:       case 0x3: {
  OPC_CheckPredicate, 46,                    // 1250:        check predicate 46
  OPC_CheckField, 20, 1, 1,                  // 1252:        check Inst[20] == 0x1
  OPC_Decode, 250, 31, 250, 2,               // 1256:        decode to t2CSNEG using decoder 378
                                             // 1256:       }
                                             // 1256:       } // switch Inst[14:12]
                                             // 1256:      }
                                             // 1256:      } // switch Inst[15]
                                             // 1256:     }
                                             // 1256:    }
  1, 0,                                      // 1261:    case 0x1: {
  OPC_SwitchField, 4, 2,                     // 1263:     switch Inst[5:4] {
  0, 11,                                     // 1266:     case 0x0: {
  OPC_CheckPredicate, 50,                    // 1268:      check predicate 50
  OPC_CheckField, 20, 1, 0,                  // 1270:      check Inst[20] == 0x0
  OPC_Decode, 249, 32, 251, 2,               // 1274:      decode to t2PKHBT using decoder 379
                                             // 1274:     }
  2, 0,                                      // 1279:     case 0x2: {
  OPC_CheckPredicate, 50,                    // 1281:      check predicate 50
  OPC_CheckField, 20, 1, 0,                  // 1283:      check Inst[20] == 0x0
  OPC_Decode, 250, 32, 251, 2,               // 1287:      decode to t2PKHTB using decoder 379
                                             // 1287:     }
                                             // 1287:     } // switch Inst[5:4]
                                             // 1287:    }
                                             // 1287:    } // switch Inst[23]
                                             // 1287:   }
  3, 0,                                      // 1292:   case 0x3: {
  OPC_SwitchField, 23, 1,                    // 1294:    switch Inst[23] {
  0, 24,                                     // 1297:    case 0x0: {
  OPC_Scope, 15,                             // 1299:     try {
  OPC_CheckField, 4, 4, 0,                   // 1301:      check Inst[7:4] == 0x0
  OPC_CheckPredicate, 9,                     // 1305:      check predicate 9
  OPC_CheckField, 12, 3, 0,                  // 1307:      check Inst[14:12] == 0x0
  OPC_Decode, 195, 31, 230, 2,               // 1311:      decode to t2ADCrr using decoder 358
                                             // 1311:     } else try {
  OPC_CheckPredicate, 9,                     // 1316:      check predicate 9
  OPC_Decode, 196, 31, 231, 2,               // 1318:      decode to t2ADCrs using decoder 359
                                             // 1318:     }
                                             // 1318:    }
  1, 0,                                      // 1323:    case 0x1: {
  OPC_Scope, 15,                             // 1325:     try {
  OPC_CheckField, 4, 4, 0,                   // 1327:      check Inst[7:4] == 0x0
  OPC_CheckPredicate, 9,                     // 1331:      check predicate 9
  OPC_CheckField, 12, 3, 0,                  // 1333:      check Inst[14:12] == 0x0
  OPC_Decode, 156, 33, 230, 2,               // 1337:      decode to t2RSBrr using decoder 358
                                             // 1337:     } else try {
  OPC_CheckPredicate, 9,                     // 1342:      check predicate 9
  OPC_Decode, 157, 33, 231, 2,               // 1344:      decode to t2RSBrs using decoder 359
                                             // 1344:     }
                                             // 1344:    }
                                             // 1344:    } // switch Inst[23]
                                             // 1344:   }
                                             // 1344:   } // switch Inst[26:24]
                                             // 1344:  }
  3, 0,                                      // 1349:  case 0x3: {
  OPC_SwitchField, 24, 3,                    // 1351:   switch Inst[26:24] {
  0, 21,                                     // 1354:   case 0x0: {
  OPC_SwitchField, 20, 1,                    // 1356:    switch Inst[20] {
  0, 7,                                      // 1359:    case 0x0: {
  OPC_CheckPredicate, 9,                     // 1361:     check predicate 9
  OPC_Decode, 255, 33, 252, 2,               // 1363:     decode to t2STRD_POST using decoder 380
                                             // 1363:    }
  1, 0,                                      // 1368:    case 0x1: {
  OPC_CheckPredicate, 9,                     // 1370:     check predicate 9
  OPC_Decode, 173, 32, 253, 2,               // 1372:     decode to t2LDRD_POST using decoder 381
                                             // 1372:    }
                                             // 1372:    } // switch Inst[20]
                                             // 1372:   }
  1, 40,                                     // 1377:   case 0x1: {
  OPC_SwitchField, 20, 1,                    // 1379:    switch Inst[20] {
  0, 7,                                      // 1382:    case 0x0: {
  OPC_CheckPredicate, 9,                     // 1384:     check predicate 9
  OPC_Decode, 128, 34, 254, 2,               // 1386:     decode to t2STRD_PRE using decoder 382
                                             // 1386:    }
  1, 0,                                      // 1391:    case 0x1: {
  OPC_Scope, 17,                             // 1393:     try {
  OPC_CheckField, 0, 20, 255, 210, 63,       // 1395:      check Inst[19:0] == 0xfe97f
  OPC_CheckPredicate, 51,                    // 1401:      check predicate 51
  OPC_CheckField, 23, 1, 0,                  // 1403:      check Inst[23] == 0x0
  OPC_Decode, 169, 33, 255, 2,               // 1407:      decode to t2SG using decoder 383
                                             // 1407:     } else try {
  OPC_CheckPredicate, 9,                     // 1412:      check predicate 9
  OPC_Decode, 174, 32, 128, 3,               // 1414:      decode to t2LDRD_PRE using decoder 384
                                             // 1414:     }
                                             // 1414:    }
                                             // 1414:    } // switch Inst[20]
                                             // 1414:   }
  2, 64,                                     // 1419:   case 0x2: {
  OPC_CheckField, 23, 1, 0,                  // 1421:    check Inst[23] == 0x0
  OPC_Scope, 33,                             // 1425:    try {
  OPC_CheckField, 4, 4, 0,                   // 1427:     check Inst[7:4] == 0x0
  OPC_CheckField, 12, 3, 0,                  // 1431:     check Inst[14:12] == 0x0
  OPC_Scope, 11,                             // 1435:     try {
  OPC_CheckField, 16, 4, 15,                 // 1437:      check Inst[19:16] == 0xf
  OPC_CheckPredicate, 9,                     // 1441:      check predicate 9
  OPC_Decode, 238, 32, 248, 2,               // 1443:      decode to t2MVNr using decoder 376
                                             // 1443:     } else try {
  OPC_CheckPredicate, 9,                     // 1448:      check predicate 9
  OPC_SoftFail, 128, 128, 2, 0,              // 1450:      softfail pos=0x00008000 neg=0x00000000
  OPC_Decode, 241, 32, 230, 2,               // 1455:      decode to t2ORNrr using decoder 358
                                             // 1455:     }
  OPC_Scope, 11,                             // 1460:    } else try {
  OPC_CheckField, 16, 4, 15,                 // 1462:     check Inst[19:16] == 0xf
  OPC_CheckPredicate, 9,                     // 1466:     check predicate 9
  OPC_Decode, 239, 32, 129, 3,               // 1468:     decode to t2MVNs using decoder 385
                                             // 1468:    } else try {
  OPC_CheckPredicate, 9,                     // 1473:     check predicate 9
  OPC_SoftFail, 128, 128, 2, 0,              // 1475:     softfail pos=0x00008000 neg=0x00000000
  OPC_Decode, 242, 32, 231, 2,               // 1480:     decode to t2ORNrs using decoder 359
                                             // 1480:    }
                                             // 1480:   }
  3, 0,                                      // 1485:   case 0x3: {
  OPC_CheckField, 23, 1, 0,                  // 1487:    check Inst[23] == 0x0
  OPC_Scope, 15,                             // 1491:    try {
  OPC_CheckField, 4, 4, 0,                   // 1493:     check Inst[7:4] == 0x0
  OPC_CheckPredicate, 9,                     // 1497:     check predicate 9
  OPC_CheckField, 12, 3, 0,                  // 1499:     check Inst[14:12] == 0x0
  OPC_Decode, 163, 33, 230, 2,               // 1503:     decode to t2SBCrr using decoder 358
                                             // 1503:    } else try {
  OPC_CheckPredicate, 9,                     // 1508:     check predicate 9
  OPC_Decode, 164, 33, 231, 2,               // 1510:     decode to t2SBCrs using decoder 359
                                             // 1510:    }
                                             // 1510:   }
                                             // 1510:   } // switch Inst[26:24]
                                             // 1510:  }
                                             // 1510:  } // switch Inst[22:21]
                                             // 1510: }
  30, 220, 10,                               // 1515: case 0x1e: {
  OPC_SwitchField, 15, 1,                    // 1518:  switch Inst[15] {
  0, 247, 3,                                 // 1521:  case 0x0: {
  OPC_SwitchField, 24, 2,                    // 1524:   switch Inst[25:24] {
  0, 108,                                    // 1527:   case 0x0: {
  OPC_SwitchField, 21, 3,                    // 1529:    switch Inst[23:21] {
  0, 24,                                     // 1532:    case 0x0: {
  OPC_Scope, 15,                             // 1534:     try {
  OPC_CheckField, 8, 4, 15,                  // 1536:      check Inst[11:8] == 0xf
  OPC_CheckPredicate, 9,                     // 1540:      check predicate 9
  OPC_CheckField, 20, 1, 1,                  // 1542:      check Inst[20] == 0x1
  OPC_Decode, 165, 34, 130, 3,               // 1546:      decode to t2TSTri using decoder 386
                                             // 1546:     } else try {
  OPC_CheckPredicate, 9,                     // 1551:      check predicate 9
  OPC_Decode, 204, 31, 131, 3,               // 1553:      decode to t2ANDri using decoder 387
                                             // 1553:     }
                                             // 1553:    }
  1, 7,                                      // 1558:    case 0x1: {
  OPC_CheckPredicate, 9,                     // 1560:     check predicate 9
  OPC_Decode, 220, 31, 131, 3,               // 1562:     decode to t2BICri using decoder 387
                                             // 1562:    }
  2, 20,                                     // 1567:    case 0x2: {
  OPC_Scope, 11,                             // 1569:     try {
  OPC_CheckField, 16, 4, 15,                 // 1571:      check Inst[19:16] == 0xf
  OPC_CheckPredicate, 9,                     // 1575:      check predicate 9
  OPC_Decode, 222, 32, 132, 3,               // 1577:      decode to t2MOVi using decoder 388
                                             // 1577:     } else try {
  OPC_CheckPredicate, 9,                     // 1582:      check predicate 9
  OPC_Decode, 243, 32, 131, 3,               // 1584:      decode to t2ORRri using decoder 387
                                             // 1584:     }
                                             // 1584:    }
  3, 20,                                     // 1589:    case 0x3: {
  OPC_Scope, 11,                             // 1591:     try {
  OPC_CheckField, 16, 4, 15,                 // 1593:      check Inst[19:16] == 0xf
  OPC_CheckPredicate, 9,                     // 1597:      check predicate 9
  OPC_Decode, 237, 32, 132, 3,               // 1599:      decode to t2MVNi using decoder 388
                                             // 1599:     } else try {
  OPC_CheckPredicate, 9,                     // 1604:      check predicate 9
  OPC_Decode, 240, 32, 131, 3,               // 1606:      decode to t2ORNri using decoder 387
                                             // 1606:     }
                                             // 1606:    }
  4, 0,                                      // 1611:    case 0x4: {
  OPC_Scope, 15,                             // 1613:     try {
  OPC_CheckField, 8, 4, 15,                  // 1615:      check Inst[11:8] == 0xf
  OPC_CheckPredicate, 9,                     // 1619:      check predicate 9
  OPC_CheckField, 20, 1, 1,                  // 1621:      check Inst[20] == 0x1
  OPC_Decode, 161, 34, 130, 3,               // 1625:      decode to t2TEQri using decoder 386
                                             // 1625:     } else try {
  OPC_CheckPredicate, 9,                     // 1630:      check predicate 9
  OPC_Decode, 130, 32, 131, 3,               // 1632:      decode to t2EORri using decoder 387
                                             // 1632:     }
                                             // 1632:    }
                                             // 1632:    } // switch Inst[23:21]
                                             // 1632:   }
  1, 110,                                    // 1637:   case 0x1: {
  OPC_SwitchField, 21, 3,                    // 1639:    switch Inst[23:21] {
  0, 38,                                     // 1642:    case 0x0: {
  OPC_Scope, 29,                             // 1644:     try {
  OPC_SwitchField, 8, 4,                     // 1646:      switch Inst[11:8] {
  13, 11,                                    // 1649:      case 0xd: {
  OPC_CheckPredicate, 9,                     // 1651:       check predicate 9
  OPC_CheckField, 16, 4, 13,                 // 1653:       check Inst[19:16] == 0xd
  OPC_Decode, 201, 31, 133, 3,               // 1657:       decode to t2ADDspImm using decoder 389
                                             // 1657:      }
  15, 0,                                     // 1662:      case 0xf: {
  OPC_CheckPredicate, 9,                     // 1664:       check predicate 9
  OPC_CheckField, 20, 1, 1,                  // 1666:       check Inst[20] == 0x1
  OPC_Decode, 232, 31, 134, 3,               // 1670:       decode to t2CMNri using decoder 390
                                             // 1670:      }
                                             // 1670:      } // switch Inst[11:8]
                                             // 1670:     } else try {
  OPC_CheckPredicate, 9,                     // 1675:      check predicate 9
  OPC_Decode, 197, 31, 135, 3,               // 1677:      decode to t2ADDri using decoder 391
                                             // 1677:     }
                                             // 1677:    }
  2, 7,                                      // 1682:    case 0x2: {
  OPC_CheckPredicate, 9,                     // 1684:     check predicate 9
  OPC_Decode, 194, 31, 131, 3,               // 1686:     decode to t2ADCri using decoder 387
                                             // 1686:    }
  3, 7,                                      // 1691:    case 0x3: {
  OPC_CheckPredicate, 9,                     // 1693:     check predicate 9
  OPC_Decode, 162, 33, 131, 3,               // 1695:     decode to t2SBCri using decoder 387
                                             // 1695:    }
  5, 38,                                     // 1700:    case 0x5: {
  OPC_Scope, 29,                             // 1702:     try {
  OPC_SwitchField, 8, 4,                     // 1704:      switch Inst[11:8] {
  13, 11,                                    // 1707:      case 0xd: {
  OPC_CheckPredicate, 9,                     // 1709:       check predicate 9
  OPC_CheckField, 16, 4, 13,                 // 1711:       check Inst[19:16] == 0xd
  OPC_Decode, 151, 34, 133, 3,               // 1715:       decode to t2SUBspImm using decoder 389
                                             // 1715:      }
  15, 0,                                     // 1720:      case 0xf: {
  OPC_CheckPredicate, 9,                     // 1722:       check predicate 9
  OPC_CheckField, 20, 1, 1,                  // 1724:       check Inst[20] == 0x1
  OPC_Decode, 235, 31, 134, 3,               // 1728:       decode to t2CMPri using decoder 390
                                             // 1728:      }
                                             // 1728:      } // switch Inst[11:8]
                                             // 1728:     } else try {
  OPC_CheckPredicate, 9,                     // 1733:      check predicate 9
  OPC_Decode, 147, 34, 135, 3,               // 1735:      decode to t2SUBri using decoder 391
                                             // 1735:     }
                                             // 1735:    }
  6, 0,                                      // 1740:    case 0x6: {
  OPC_CheckPredicate, 9,                     // 1742:     check predicate 9
  OPC_Decode, 155, 33, 131, 3,               // 1744:     decode to t2RSBri using decoder 387
                                             // 1744:    }
                                             // 1744:    } // switch Inst[23:21]
                                             // 1744:   }
  2, 122,                                    // 1749:   case 0x2: {
  OPC_SwitchField, 22, 1,                    // 1751:    switch Inst[22] {
  0, 86,                                     // 1754:    case 0x0: {
  OPC_CheckField, 20, 1, 0,                  // 1756:     check Inst[20] == 0x0
  OPC_Scope, 51,                             // 1760:     try {
  OPC_SwitchField, 16, 4,                    // 1762:      switch Inst[19:16] {
  13, 37,                                    // 1765:      case 0xd: {
  OPC_SwitchField, 21, 1,                    // 1767:       switch Inst[21] {
  0, 15,                                     // 1770:       case 0x0: {
  OPC_CheckPredicate, 9,                     // 1772:        check predicate 9
  OPC_CheckField, 23, 1, 0,                  // 1774:        check Inst[23] == 0x0
  OPC_CheckField, 8, 4, 13,                  // 1778:        check Inst[11:8] == 0xd
  OPC_Decode, 202, 31, 133, 3,               // 1782:        decode to t2ADDspImm12 using decoder 389
                                             // 1782:       }
  1, 0,                                      // 1787:       case 0x1: {
  OPC_CheckPredicate, 9,                     // 1789:        check predicate 9
  OPC_CheckField, 23, 1, 1,                  // 1791:        check Inst[23] == 0x1
  OPC_CheckField, 8, 4, 13,                  // 1795:        check Inst[11:8] == 0xd
  OPC_Decode, 152, 34, 133, 3,               // 1799:        decode to t2SUBspImm12 using decoder 389
                                             // 1799:       }
                                             // 1799:       } // switch Inst[21]
                                             // 1799:      }
  15, 0,                                     // 1804:      case 0xf: {
  OPC_CheckPredicate, 9,                     // 1806:       check predicate 9
  OPC_Decode, 203, 31, 136, 3,               // 1808:       decode to t2ADR using decoder 392
                                             // 1808:      }
                                             // 1808:      } // switch Inst[19:16]
                                             // 1808:     } else try {
  OPC_SwitchField, 21, 1,                    // 1813:      switch Inst[21] {
  0, 11,                                     // 1816:      case 0x0: {
  OPC_CheckPredicate, 9,                     // 1818:       check predicate 9
  OPC_CheckField, 23, 1, 0,                  // 1820:       check Inst[23] == 0x0
  OPC_Decode, 198, 31, 137, 3,               // 1824:       decode to t2ADDri12 using decoder 393
                                             // 1824:      }
  1, 0,                                      // 1829:      case 0x1: {
  OPC_CheckPredicate, 9,                     // 1831:       check predicate 9
  OPC_CheckField, 23, 1, 1,                  // 1833:       check Inst[23] == 0x1
  OPC_Decode, 148, 34, 137, 3,               // 1837:       decode to t2SUBri12 using decoder 393
                                             // 1837:      }
                                             // 1837:      } // switch Inst[21]
                                             // 1837:     }
                                             // 1837:    }
  1, 0,                                      // 1842:    case 0x1: {
  OPC_SwitchField, 23, 1,                    // 1844:     switch Inst[23] {
  0, 11,                                     // 1847:     case 0x0: {
  OPC_CheckPredicate, 4,                     // 1849:      check predicate 4
  OPC_CheckField, 20, 2, 0,                  // 1851:      check Inst[21:20] == 0x0
  OPC_Decode, 223, 32, 138, 3,               // 1855:      decode to t2MOVi16 using decoder 394
                                             // 1855:     }
  1, 0,                                      // 1860:     case 0x1: {
  OPC_CheckPredicate, 4,                     // 1862:      check predicate 4
  OPC_CheckField, 20, 2, 0,                  // 1864:      check Inst[21:20] == 0x0
  OPC_Decode, 221, 32, 138, 3,               // 1868:      decode to t2MOVTi16 using decoder 394
                                             // 1868:     }
                                             // 1868:     } // switch Inst[23]
                                             // 1868:    }
                                             // 1868:    } // switch Inst[22]
                                             // 1868:   }
  3, 0,                                      // 1873:   case 0x3: {
  OPC_SwitchField, 22, 2,                    // 1875:    switch Inst[23:22] {
  0, 44,                                     // 1878:    case 0x0: {
  OPC_CheckField, 5, 1, 0,                   // 1880:     check Inst[5] == 0x0
  OPC_CheckField, 20, 1, 0,                  // 1884:     check Inst[20] == 0x0
  OPC_CheckField, 26, 1, 0,                  // 1888:     check Inst[26] == 0x0
  OPC_Scope, 23,                             // 1892:     try {
  OPC_CheckField, 4, 1, 0,                   // 1894:      check Inst[4] == 0x0
  OPC_CheckPredicate, 52,                    // 1898:      check predicate 52
  OPC_CheckField, 21, 1, 1,                  // 1900:      check Inst[21] == 0x1
  OPC_CheckField, 12, 3, 0,                  // 1904:      check Inst[14:12] == 0x0
  OPC_CheckField, 6, 2, 0,                   // 1908:      check Inst[7:6] == 0x0
  OPC_Decode, 218, 33, 139, 3,               // 1912:      decode to t2SSAT16 using decoder 395
                                             // 1912:     } else try {
  OPC_CheckPredicate, 9,                     // 1917:      check predicate 9
  OPC_Decode, 217, 33, 140, 3,               // 1919:      decode to t2SSAT using decoder 396
                                             // 1919:     }
                                             // 1919:    }
  1, 42,                                     // 1924:    case 0x1: {
  OPC_SwitchField, 20, 2,                    // 1926:     switch Inst[21:20] {
  0, 7,                                      // 1929:     case 0x0: {
  OPC_CheckPredicate, 9,                     // 1931:      check predicate 9
  OPC_Decode, 165, 33, 141, 3,               // 1933:      decode to t2SBFX using decoder 397
                                             // 1933:     }
  2, 0,                                      // 1938:     case 0x2: {
  OPC_CheckField, 5, 1, 0,                   // 1940:      check Inst[5] == 0x0
  OPC_CheckField, 26, 1, 0,                  // 1944:      check Inst[26] == 0x0
  OPC_Scope, 11,                             // 1948:      try {
  OPC_CheckField, 16, 4, 15,                 // 1950:       check Inst[19:16] == 0xf
  OPC_CheckPredicate, 9,                     // 1954:       check predicate 9
  OPC_Decode, 213, 31, 142, 3,               // 1956:       decode to t2BFC using decoder 398
                                             // 1956:      } else try {
  OPC_CheckPredicate, 9,                     // 1961:       check predicate 9
  OPC_Decode, 214, 31, 143, 3,               // 1963:       decode to t2BFI using decoder 399
                                             // 1963:      }
                                             // 1963:     }
                                             // 1963:     } // switch Inst[21:20]
                                             // 1963:    }
  2, 44,                                     // 1968:    case 0x2: {
  OPC_CheckField, 5, 1, 0,                   // 1970:     check Inst[5] == 0x0
  OPC_CheckField, 20, 1, 0,                  // 1974:     check Inst[20] == 0x0
  OPC_CheckField, 26, 1, 0,                  // 1978:     check Inst[26] == 0x0
  OPC_Scope, 23,                             // 1982:     try {
  OPC_CheckField, 4, 1, 0,                   // 1984:      check Inst[4] == 0x0
  OPC_CheckPredicate, 52,                    // 1988:      check predicate 52
  OPC_CheckField, 21, 1, 1,                  // 1990:      check Inst[21] == 0x1
  OPC_CheckField, 12, 3, 0,                  // 1994:      check Inst[14:12] == 0x0
  OPC_CheckField, 6, 2, 0,                   // 1998:      check Inst[7:6] == 0x0
  OPC_Decode, 196, 34, 139, 3,               // 2002:      decode to t2USAT16 using decoder 395
                                             // 2002:     } else try {
  OPC_CheckPredicate, 9,                     // 2007:      check predicate 9
  OPC_Decode, 195, 34, 140, 3,               // 2009:      decode to t2USAT using decoder 396
                                             // 2009:     }
                                             // 2009:    }
  3, 0,                                      // 2014:    case 0x3: {
  OPC_CheckPredicate, 9,                     // 2016:     check predicate 9
  OPC_CheckField, 20, 2, 0,                  // 2018:     check Inst[21:20] == 0x0
  OPC_Decode, 175, 34, 141, 3,               // 2022:     decode to t2UBFX using decoder 397
                                             // 2022:    }
                                             // 2022:    } // switch Inst[23:22]
                                             // 2022:   }
                                             // 2022:   } // switch Inst[25:24]
                                             // 2022:  }
  1, 0,                                      // 2027:  case 0x1: {
  OPC_SwitchField, 12, 1,                    // 2029:   switch Inst[12] {
  0, 202, 6,                                 // 2032:   case 0x0: {
  OPC_SwitchField, 14, 1,                    // 2035:    switch Inst[14] {
  0, 164, 4,                                 // 2038:    case 0x0: {
  OPC_Scope, 111,                            // 2041:     try {
  OPC_SwitchField, 0, 12,                    // 2043:      switch Inst[11:0] {
  1, 16,                                     // 2046:      case 0x1: {
  OPC_CheckPredicate, 53,                    // 2048:       check predicate 53
  OPC_CheckField, 16, 11, 143, 15,           // 2050:       check Inst[26:16] == 0x78f
  OPC_CheckField, 13, 1, 0,                  // 2055:       check Inst[13] == 0x0
  OPC_Decode, 252, 31, 255, 2,               // 2059:       decode to t2DCPS1 using decoder 383
                                             // 2059:      }
  2, 16,                                     // 2064:      case 0x2: {
  OPC_CheckPredicate, 53,                    // 2066:       check predicate 53
  OPC_CheckField, 16, 11, 143, 15,           // 2068:       check Inst[26:16] == 0x78f
  OPC_CheckField, 13, 1, 0,                  // 2073:       check Inst[13] == 0x0
  OPC_Decode, 253, 31, 255, 2,               // 2077:       decode to t2DCPS2 using decoder 383
                                             // 2077:      }
  3, 16,                                     // 2082:      case 0x3: {
  OPC_CheckPredicate, 53,                    // 2084:       check predicate 53
  OPC_CheckField, 16, 11, 143, 15,           // 2086:       check Inst[26:16] == 0x78f
  OPC_CheckField, 13, 1, 0,                  // 2091:       check Inst[13] == 0x0
  OPC_Decode, 254, 31, 255, 2,               // 2095:       decode to t2DCPS3 using decoder 383
                                             // 2095:      }
  18, 15,                                    // 2100:      case 0x12: {
  OPC_CheckPredicate, 54,                    // 2102:       check predicate 54
  OPC_CheckField, 16, 11, 175, 7,            // 2104:       check Inst[26:16] == 0x3af
  OPC_CheckField, 13, 1, 0,                  // 2109:       check Inst[13] == 0x0
  OPC_Decode, 164, 34, 89,                   // 2113:       decode to t2TSB using decoder 89
                                             // 2113:      }
  128, 30, 15,                               // 2117:      case 0xf00: {
  OPC_CheckPredicate, 45,                    // 2120:       check predicate 45
  OPC_CheckField, 20, 7, 60,                 // 2122:       check Inst[26:20] == 0x3c
  OPC_CheckField, 13, 1, 0,                  // 2126:       check Inst[13] == 0x0
  OPC_Decode, 225, 31, 144, 3,               // 2130:       decode to t2BXJ using decoder 400
                                             // 2130:      }
  175, 30, 0,                                // 2135:      case 0xf2f: {
  OPC_CheckPredicate, 55,                    // 2138:       check predicate 55
  OPC_CheckField, 16, 11, 191, 7,            // 2140:       check Inst[26:16] == 0x3bf
  OPC_CheckField, 13, 1, 0,                  // 2145:       check Inst[13] == 0x0
  OPC_Decode, 229, 31, 255, 2,               // 2149:       decode to t2CLREX using decoder 383
                                             // 2149:      }
                                             // 2149:      } // switch Inst[11:0]
  OPC_Scope, 191, 1,                         // 2154:     } else try {
  OPC_SwitchField, 16, 11,                   // 2157:      switch Inst[26:16] {
  175, 7, 84,                                // 2160:      case 0x3af: {
  OPC_SwitchField, 8, 1,                     // 2163:       switch Inst[8] {
  0, 45,                                     // 2166:       case 0x0: {
  OPC_CheckField, 11, 1, 0,                  // 2168:        check Inst[11] == 0x0
  OPC_CheckField, 13, 1, 0,                  // 2172:        check Inst[13] == 0x0
  OPC_Scope, 24,                             // 2176:        try {
  OPC_CheckField, 9, 2, 0,                   // 2178:         check Inst[10:9] == 0x0
  OPC_Scope, 11,                             // 2182:         try {
  OPC_CheckField, 4, 4, 15,                  // 2184:          check Inst[7:4] == 0xf
  OPC_CheckPredicate, 9,                     // 2188:          check predicate 9
  OPC_Decode, 251, 31, 145, 3,               // 2190:          decode to t2DBG using decoder 401
                                             // 2190:         } else try {
  OPC_CheckPredicate, 9,                     // 2195:          check predicate 9
  OPC_Decode, 133, 32, 146, 3,               // 2197:          decode to t2HINT using decoder 402
                                             // 2197:         }
                                             // 2197:        } else try {
  OPC_CheckPredicate, 45,                    // 2202:         check predicate 45
  OPC_CheckField, 0, 5, 0,                   // 2204:         check Inst[4:0] == 0x0
  OPC_Decode, 239, 31, 147, 3,               // 2208:         decode to t2CPS2p using decoder 403
                                             // 2208:        }
                                             // 2208:       }
  1, 0,                                      // 2213:       case 0x1: {
  OPC_CheckField, 11, 1, 0,                  // 2215:        check Inst[11] == 0x0
  OPC_CheckField, 13, 1, 0,                  // 2219:        check Inst[13] == 0x0
  OPC_Scope, 15,                             // 2223:        try {
  OPC_CheckField, 5, 3, 0,                   // 2225:         check Inst[7:5] == 0x0
  OPC_CheckPredicate, 45,                    // 2229:         check predicate 45
  OPC_CheckField, 9, 2, 0,                   // 2231:         check Inst[10:9] == 0x0
  OPC_Decode, 238, 31, 147, 3,               // 2235:         decode to t2CPS1p using decoder 403
                                             // 2235:        } else try {
  OPC_CheckPredicate, 45,                    // 2240:         check predicate 45
  OPC_Decode, 240, 31, 147, 3,               // 2242:         decode to t2CPS3p using decoder 403
                                             // 2242:        }
                                             // 2242:       }
                                             // 2242:       } // switch Inst[8]
                                             // 2242:      }
  191, 7, 45,                                // 2247:      case 0x3bf: {
  OPC_SwitchField, 4, 8,                     // 2250:       switch Inst[11:4] {
  244, 1, 11,                                // 2253:       case 0xf4: {
  OPC_CheckPredicate, 56,                    // 2256:        check predicate 56
  OPC_CheckField, 13, 1, 0,                  // 2258:        check Inst[13] == 0x0
  OPC_Decode, 129, 32, 148, 3,               // 2262:        decode to t2DSB using decoder 404
                                             // 2262:       }
  245, 1, 11,                                // 2267:       case 0xf5: {
  OPC_CheckPredicate, 56,                    // 2270:        check predicate 56
  OPC_CheckField, 13, 1, 0,                  // 2272:        check Inst[13] == 0x0
  OPC_Decode, 128, 32, 148, 3,               // 2276:        decode to t2DMB using decoder 404
                                             // 2276:       }
  246, 1, 0,                                 // 2281:       case 0xf6: {
  OPC_CheckPredicate, 56,                    // 2284:        check predicate 56
  OPC_CheckField, 13, 1, 0,                  // 2286:        check Inst[13] == 0x0
  OPC_Decode, 135, 32, 149, 3,               // 2290:        decode to t2ISB using decoder 405
                                             // 2290:       }
                                             // 2290:       } // switch Inst[11:4]
                                             // 2290:      }
  222, 7, 14,                                // 2295:      case 0x3de: {
  OPC_CheckPredicate, 45,                    // 2298:       check predicate 45
  OPC_CheckField, 13, 1, 0,                  // 2300:       check Inst[13] == 0x0
  OPC_CheckField, 8, 4, 15,                  // 2304:       check Inst[11:8] == 0xf
  OPC_Decode, 146, 34, 26,                   // 2308:       decode to t2SUBS_PC_LR using decoder 26
                                             // 2308:      }
  239, 7, 15,                                // 2312:      case 0x3ef: {
  OPC_CheckPredicate, 45,                    // 2315:       check predicate 45
  OPC_CheckField, 13, 1, 0,                  // 2317:       check Inst[13] == 0x0
  OPC_CheckField, 0, 8, 0,                   // 2321:       check Inst[7:0] == 0x0
  OPC_Decode, 229, 32, 150, 3,               // 2325:       decode to t2MRS_AR using decoder 406
                                             // 2325:      }
  255, 7, 0,                                 // 2330:      case 0x3ff: {
  OPC_CheckPredicate, 45,                    // 2333:       check predicate 45
  OPC_CheckField, 13, 1, 0,                  // 2335:       check Inst[13] == 0x0
  OPC_CheckField, 0, 8, 0,                   // 2339:       check Inst[7:0] == 0x0
  OPC_Decode, 232, 32, 150, 3,               // 2343:       decode to t2MRSsys_AR using decoder 406
                                             // 2343:      }
                                             // 2343:      } // switch Inst[26:16]
  OPC_Scope, 79,                             // 2348:     } else try {
  OPC_SwitchField, 0, 11,                    // 2350:      switch Inst[10:0] {
  13, 17,                                    // 2353:      case 0xd: {
  OPC_CheckPredicate, 57,                    // 2355:       check predicate 57
  OPC_CheckField, 20, 7, 58,                 // 2357:       check Inst[26:20] == 0x3a
  OPC_SoftFail, 128, 80, 128, 128, 60,       // 2361:       softfail pos=0x00002800 neg=0x000f0000
  OPC_Decode, 247, 32, 146, 3,               // 2367:       decode to t2PACBTI using decoder 402
                                             // 2367:      }
  15, 17,                                    // 2372:      case 0xf: {
  OPC_CheckPredicate, 57,                    // 2374:       check predicate 57
  OPC_CheckField, 20, 7, 58,                 // 2376:       check Inst[26:20] == 0x3a
  OPC_SoftFail, 128, 80, 128, 128, 60,       // 2380:       softfail pos=0x00002800 neg=0x000f0000
  OPC_Decode, 223, 31, 146, 3,               // 2386:       decode to t2BTI using decoder 402
                                             // 2386:      }
  29, 17,                                    // 2391:      case 0x1d: {
  OPC_CheckPredicate, 57,                    // 2393:       check predicate 57
  OPC_CheckField, 20, 7, 58,                 // 2395:       check Inst[26:20] == 0x3a
  OPC_SoftFail, 128, 80, 128, 128, 60,       // 2399:       softfail pos=0x00002800 neg=0x000f0000
  OPC_Decode, 246, 32, 146, 3,               // 2405:       decode to t2PAC using decoder 402
                                             // 2405:      }
  45, 0,                                     // 2410:      case 0x2d: {
  OPC_CheckPredicate, 57,                    // 2412:       check predicate 57
  OPC_CheckField, 20, 7, 58,                 // 2414:       check Inst[26:20] == 0x3a
  OPC_SoftFail, 128, 80, 128, 128, 60,       // 2418:       softfail pos=0x00002800 neg=0x000f0000
  OPC_Decode, 210, 31, 146, 3,               // 2424:       decode to t2AUT using decoder 402
                                             // 2424:      }
                                             // 2424:      } // switch Inst[10:0]
  OPC_Scope, 57,                             // 2429:     } else try {
  OPC_SwitchField, 20, 7,                    // 2431:      switch Inst[26:20] {
  59, 16,                                    // 2434:      case 0x3b: {
  OPC_CheckPredicate, 58,                    // 2436:       check predicate 58
  OPC_CheckField, 4, 4, 7,                   // 2438:       check Inst[7:4] == 0x7
  OPC_SoftFail, 143, 64, 128, 158, 60,       // 2442:       softfail pos=0x0000200f neg=0x000f0f00
  OPC_Decode, 161, 33, 25,                   // 2448:       decode to t2SB using decoder 25
                                             // 2448:      }
  126, 11,                                   // 2452:      case 0x7e: {
  OPC_CheckPredicate, 59,                    // 2454:       check predicate 59
  OPC_CheckField, 13, 1, 0,                  // 2456:       check Inst[13] == 0x0
  OPC_Decode, 134, 32, 151, 3,               // 2460:       decode to t2HVC using decoder 407
                                             // 2460:      }
  127, 0,                                    // 2465:      case 0x7f: {
  OPC_SwitchField, 13, 1,                    // 2467:       switch Inst[13] {
  0, 7,                                      // 2470:       case 0x0: {
  OPC_CheckPredicate, 60,                    // 2472:        check predicate 60
  OPC_Decode, 176, 33, 152, 3,               // 2474:        decode to t2SMC using decoder 408
                                             // 2474:       }
  1, 0,                                      // 2479:       case 0x1: {
  OPC_CheckPredicate, 9,                     // 2481:        check predicate 9
  OPC_Decode, 176, 34, 151, 3,               // 2483:        decode to t2UDF using decoder 407
                                             // 2483:       }
                                             // 2483:       } // switch Inst[13]
                                             // 2483:      }
                                             // 2483:      } // switch Inst[26:20]
  OPC_Scope, 92,                             // 2488:     } else try {
  OPC_SwitchField, 21, 6,                    // 2490:      switch Inst[26:21] {
  28, 50,                                    // 2493:      case 0x1c: {
  OPC_Scope, 15,                             // 2495:       try {
  OPC_CheckField, 0, 8, 0,                   // 2497:        check Inst[7:0] == 0x0
  OPC_CheckPredicate, 45,                    // 2501:        check predicate 45
  OPC_CheckField, 13, 1, 0,                  // 2503:        check Inst[13] == 0x0
  OPC_Decode, 233, 32, 153, 3,               // 2507:        decode to t2MSR_AR using decoder 409
  OPC_Scope, 19,                             // 2512:       } else try {
  OPC_CheckField, 0, 4, 0,                   // 2514:        check Inst[3:0] == 0x0
  OPC_CheckPredicate, 61,                    // 2518:        check predicate 61
  OPC_CheckField, 13, 1, 0,                  // 2520:        check Inst[13] == 0x0
  OPC_CheckField, 5, 3, 1,                   // 2524:        check Inst[7:5] == 0x1
  OPC_Decode, 235, 32, 154, 3,               // 2528:        decode to t2MSRbanked using decoder 410
                                             // 2528:       } else try {
  OPC_CheckPredicate, 62,                    // 2533:        check predicate 62
  OPC_SoftFail, 128, 198, 64, 0,             // 2535:        softfail pos=0x00102300 neg=0x00000000
  OPC_Decode, 234, 32, 155, 3,               // 2540:        decode to t2MSR_M using decoder 411
                                             // 2540:       }
                                             // 2540:      }
  31, 0,                                     // 2545:      case 0x1f: {
  OPC_Scope, 19,                             // 2547:       try {
  OPC_CheckField, 0, 4, 0,                   // 2549:        check Inst[3:0] == 0x0
  OPC_CheckPredicate, 61,                    // 2553:        check predicate 61
  OPC_CheckField, 13, 1, 0,                  // 2555:        check Inst[13] == 0x0
  OPC_CheckField, 5, 3, 1,                   // 2559:        check Inst[7:5] == 0x1
  OPC_Decode, 231, 32, 156, 3,               // 2563:        decode to t2MRSbanked using decoder 412
                                             // 2563:       } else try {
  OPC_CheckPredicate, 62,                    // 2568:        check predicate 62
  OPC_SoftFail, 128, 192, 64, 128, 128, 60,  // 2570:        softfail pos=0x00102000 neg=0x000f0000
  OPC_Decode, 230, 32, 157, 3,               // 2577:        decode to t2MRS_M using decoder 413
                                             // 2577:       }
                                             // 2577:      }
                                             // 2577:      } // switch Inst[26:21]
                                             // 2577:     } else try {
  OPC_CheckPredicate, 9,                     // 2582:      check predicate 9
  OPC_Decode, 226, 31, 158, 3,               // 2584:      decode to t2Bcc using decoder 414
                                             // 2584:     }
                                             // 2584:    }
  1, 0,                                      // 2589:    case 0x1: {
  OPC_SwitchField, 13, 1,                    // 2591:     switch Inst[13] {
  0, 93,                                     // 2594:     case 0x0: {
  OPC_CheckField, 0, 1, 1,                   // 2596:      check Inst[0] == 0x1
  OPC_Scope, 30,                             // 2600:      try {
  OPC_SwitchField, 16, 11,                   // 2602:       switch Inst[26:16] {
  15, 7,                                     // 2605:       case 0xf: {
  OPC_CheckPredicate, 63,                    // 2607:        check predicate 63
  OPC_Decode, 209, 32, 159, 3,               // 2609:        decode to t2LEUpdate using decoder 415
                                             // 2609:       }
  31, 7,                                     // 2614:       case 0x1f: {
  OPC_CheckPredicate, 31,                    // 2616:        check predicate 31
  OPC_Decode, 249, 7, 159, 3,                // 2618:        decode to MVE_LETP using decoder 415
                                             // 2618:       }
  47, 0,                                     // 2623:       case 0x2f: {
  OPC_CheckPredicate, 63,                    // 2625:        check predicate 63
  OPC_Decode, 208, 32, 159, 3,               // 2627:        decode to t2LE using decoder 415
                                             // 2627:       }
                                             // 2627:       } // switch Inst[26:16]
  OPC_Scope, 48,                             // 2632:      } else try {
  OPC_SwitchField, 20, 7,                    // 2634:       switch Inst[26:20] {
  0, 7,                                      // 2637:       case 0x0: {
  OPC_CheckPredicate, 31,                    // 2639:        check predicate 31
  OPC_Decode, 186, 14, 159, 3,               // 2641:        decode to MVE_WLSTP_8 using decoder 415
                                             // 2641:       }
  1, 7,                                      // 2646:       case 0x1: {
  OPC_CheckPredicate, 31,                    // 2648:        check predicate 31
  OPC_Decode, 183, 14, 159, 3,               // 2650:        decode to MVE_WLSTP_16 using decoder 415
                                             // 2650:       }
  2, 7,                                      // 2655:       case 0x2: {
  OPC_CheckPredicate, 31,                    // 2657:        check predicate 31
  OPC_Decode, 184, 14, 159, 3,               // 2659:        decode to MVE_WLSTP_32 using decoder 415
                                             // 2659:       }
  3, 7,                                      // 2664:       case 0x3: {
  OPC_CheckPredicate, 31,                    // 2666:        check predicate 31
  OPC_Decode, 185, 14, 159, 3,               // 2668:        decode to MVE_WLSTP_64 using decoder 415
                                             // 2668:       }
  4, 0,                                      // 2673:       case 0x4: {
  OPC_CheckPredicate, 63,                    // 2675:        check predicate 63
  OPC_Decode, 206, 34, 159, 3,               // 2677:        decode to t2WLS using decoder 415
                                             // 2677:       }
                                             // 2677:       } // switch Inst[26:20]
                                             // 2677:      } else try {
  OPC_CheckPredicate, 63,                    // 2682:       check predicate 63
  OPC_Decode, 215, 31, 160, 3,               // 2684:       decode to t2BFLi using decoder 416
                                             // 2684:      }
                                             // 2684:     }
  1, 0,                                      // 2689:     case 0x1: {
  OPC_SwitchField, 22, 1,                    // 2691:      switch Inst[22] {
  0, 111,                                    // 2694:      case 0x0: {
  OPC_CheckField, 0, 1, 1,                   // 2696:       check Inst[0] == 0x1
  OPC_Scope, 75,                             // 2700:       try {
  OPC_CheckField, 11, 1, 0,                  // 2702:        check Inst[11] == 0x0
  OPC_SwitchField, 20, 2,                    // 2706:        switch Inst[21:20] {
  0, 15,                                     // 2709:        case 0x0: {
  OPC_CheckPredicate, 31,                    // 2711:         check predicate 31
  OPC_CheckField, 23, 4, 0,                  // 2713:         check Inst[26:23] == 0x0
  OPC_SoftFail, 254, 15, 0,                  // 2717:         softfail pos=0x000007fe neg=0x00000000
  OPC_Decode, 247, 7, 159, 3,                // 2721:         decode to MVE_DLSTP_8 using decoder 415
                                             // 2721:        }
  1, 15,                                     // 2726:        case 0x1: {
  OPC_CheckPredicate, 31,                    // 2728:         check predicate 31
  OPC_CheckField, 23, 4, 0,                  // 2730:         check Inst[26:23] == 0x0
  OPC_SoftFail, 254, 15, 0,                  // 2734:         softfail pos=0x000007fe neg=0x00000000
  OPC_Decode, 244, 7, 159, 3,                // 2738:         decode to MVE_DLSTP_16 using decoder 415
                                             // 2738:        }
  2, 15,                                     // 2743:        case 0x2: {
  OPC_CheckPredicate, 31,                    // 2745:         check predicate 31
  OPC_CheckField, 23, 4, 0,                  // 2747:         check Inst[26:23] == 0x0
  OPC_SoftFail, 254, 15, 0,                  // 2751:         softfail pos=0x000007fe neg=0x00000000
  OPC_Decode, 245, 7, 159, 3,                // 2755:         decode to MVE_DLSTP_32 using decoder 415
                                             // 2755:        }
  3, 0,                                      // 2760:        case 0x3: {
  OPC_CheckPredicate, 31,                    // 2762:         check predicate 31
  OPC_CheckField, 23, 4, 0,                  // 2764:         check Inst[26:23] == 0x0
  OPC_SoftFail, 254, 15, 0,                  // 2768:         softfail pos=0x000007fe neg=0x00000000
  OPC_Decode, 246, 7, 159, 3,                // 2772:         decode to MVE_DLSTP_64 using decoder 415
                                             // 2772:        }
                                             // 2772:        } // switch Inst[21:20]
  OPC_Scope, 21,                             // 2777:       } else try {
  OPC_CheckField, 16, 4, 15,                 // 2779:        check Inst[19:16] == 0xf
  OPC_CheckPredicate, 31,                    // 2783:        check predicate 31
  OPC_CheckField, 23, 4, 0,                  // 2785:        check Inst[26:23] == 0x0
  OPC_SoftFail, 254, 159, 192, 1, 0,         // 2789:        softfail pos=0x00300ffe neg=0x00000000
  OPC_Decode, 248, 7, 159, 3,                // 2795:        decode to MVE_LCTP using decoder 415
                                             // 2795:       } else try {
  OPC_CheckPredicate, 63,                    // 2800:        check predicate 63
  OPC_Decode, 218, 31, 161, 3,               // 2802:        decode to t2BFic using decoder 417
                                             // 2802:       }
                                             // 2802:      }
  1, 0,                                      // 2807:      case 0x1: {
  OPC_SwitchField, 21, 1,                    // 2809:       switch Inst[21] {
  0, 32,                                     // 2812:       case 0x0: {
  OPC_CheckField, 0, 1, 1,                   // 2814:        check Inst[0] == 0x1
  OPC_Scope, 19,                             // 2818:        try {
  OPC_CheckField, 1, 11, 0,                  // 2820:         check Inst[11:1] == 0x0
  OPC_CheckPredicate, 63,                    // 2824:         check predicate 63
  OPC_CheckField, 23, 4, 0,                  // 2826:         check Inst[26:23] == 0x0
  OPC_CheckField, 20, 1, 0,                  // 2830:         check Inst[20] == 0x0
  OPC_Decode, 255, 31, 159, 3,               // 2834:         decode to t2DLS using decoder 415
                                             // 2834:        } else try {
  OPC_CheckPredicate, 63,                    // 2839:         check predicate 63
  OPC_Decode, 217, 31, 162, 3,               // 2841:         decode to t2BFi using decoder 418
                                             // 2841:        }
                                             // 2841:       }
  1, 0,                                      // 2846:       case 0x1: {
  OPC_SwitchField, 20, 1,                    // 2848:        switch Inst[20] {
  0, 11,                                     // 2851:        case 0x0: {
  OPC_CheckPredicate, 63,                    // 2853:         check predicate 63
  OPC_CheckField, 0, 12, 1,                  // 2855:         check Inst[11:0] == 0x1
  OPC_Decode, 219, 31, 163, 3,               // 2859:         decode to t2BFr using decoder 419
                                             // 2859:        }
  1, 0,                                      // 2864:        case 0x1: {
  OPC_CheckPredicate, 63,                    // 2866:         check predicate 63
  OPC_CheckField, 0, 12, 1,                  // 2868:         check Inst[11:0] == 0x1
  OPC_Decode, 216, 31, 163, 3,               // 2872:         decode to t2BFLr using decoder 419
                                             // 2872:        }
                                             // 2872:        } // switch Inst[20]
                                             // 2872:       }
                                             // 2872:       } // switch Inst[21]
                                             // 2872:      }
                                             // 2872:      } // switch Inst[22]
                                             // 2872:     }
                                             // 2872:     } // switch Inst[13]
                                             // 2872:    }
                                             // 2872:    } // switch Inst[14]
                                             // 2872:   }
  1, 0,                                      // 2877:   case 0x1: {
  OPC_CheckPredicate, 4,                     // 2879:    check predicate 4
  OPC_CheckField, 14, 1, 0,                  // 2881:    check Inst[14] == 0x0
  OPC_Decode, 212, 31, 164, 3,               // 2885:    decode to t2B using decoder 420
                                             // 2885:   }
                                             // 2885:   } // switch Inst[12]
                                             // 2885:  }
                                             // 2885:  } // switch Inst[15]
                                             // 2885: }
  31, 0,                                     // 2890: case 0x1f: {
  OPC_SwitchField, 21, 2,                    // 2892:  switch Inst[22:21] {
  0, 255, 7,                                 // 2895:  case 0x0: {
  OPC_SwitchField, 24, 3,                    // 2898:   switch Inst[26:24] {
  0, 231, 1,                                 // 2901:   case 0x0: {
  OPC_SwitchField, 20, 1,                    // 2904:    switch Inst[20] {
  0, 79,                                     // 2907:    case 0x0: {
  OPC_SwitchField, 23, 1,                    // 2909:     switch Inst[23] {
  0, 65,                                     // 2912:     case 0x0: {
  OPC_SwitchField, 10, 2,                    // 2914:      switch Inst[11:10] {
  0, 11,                                     // 2917:      case 0x0: {
  OPC_CheckPredicate, 9,                     // 2919:       check predicate 9
  OPC_CheckField, 6, 4, 0,                   // 2921:       check Inst[9:6] == 0x0
  OPC_Decode, 254, 33, 165, 3,               // 2925:       decode to t2STRBs using decoder 421
                                             // 2925:      }
  2, 11,                                     // 2930:      case 0x2: {
  OPC_CheckPredicate, 9,                     // 2932:       check predicate 9
  OPC_CheckField, 8, 1, 1,                   // 2934:       check Inst[8] == 0x1
  OPC_Decode, 250, 33, 166, 3,               // 2938:       decode to t2STRB_POST using decoder 422
                                             // 2938:      }
  3, 0,                                      // 2943:      case 0x3: {
  OPC_SwitchField, 8, 1,                     // 2945:       switch Inst[8] {
  0, 20,                                     // 2948:       case 0x0: {
  OPC_Scope, 11,                             // 2950:        try {
  OPC_CheckField, 9, 1, 1,                   // 2952:         check Inst[9] == 0x1
  OPC_CheckPredicate, 9,                     // 2956:         check predicate 9
  OPC_Decode, 249, 33, 167, 3,               // 2958:         decode to t2STRBT using decoder 423
                                             // 2958:        } else try {
  OPC_CheckPredicate, 9,                     // 2963:         check predicate 9
  OPC_Decode, 253, 33, 168, 3,               // 2965:         decode to t2STRBi8 using decoder 424
                                             // 2965:        }
                                             // 2965:       }
  1, 0,                                      // 2970:       case 0x1: {
  OPC_CheckPredicate, 9,                     // 2972:        check predicate 9
  OPC_Decode, 251, 33, 166, 3,               // 2974:        decode to t2STRB_PRE using decoder 422
                                             // 2974:       }
                                             // 2974:       } // switch Inst[8]
                                             // 2974:      }
                                             // 2974:      } // switch Inst[11:10]
                                             // 2974:     }
  1, 0,                                      // 2979:     case 0x1: {
  OPC_CheckPredicate, 9,                     // 2981:      check predicate 9
  OPC_Decode, 252, 33, 169, 3,               // 2983:      decode to t2STRBi12 using decoder 425
                                             // 2983:     }
                                             // 2983:     } // switch Inst[23]
                                             // 2983:    }
  1, 0,                                      // 2988:    case 0x1: {
  OPC_Scope, 119,                            // 2990:     try {
  OPC_SwitchField, 23, 1,                    // 2992:      switch Inst[23] {
  0, 92,                                     // 2995:      case 0x0: {
  OPC_SwitchField, 10, 2,                    // 2997:       switch Inst[11:10] {
  0, 24,                                     // 3000:       case 0x0: {
  OPC_CheckField, 6, 4, 0,                   // 3002:        check Inst[9:6] == 0x0
  OPC_Scope, 11,                             // 3006:        try {
  OPC_CheckField, 12, 4, 15,                 // 3008:         check Inst[15:12] == 0xf
  OPC_CheckPredicate, 9,                     // 3012:         check predicate 9
  OPC_Decode, 129, 33, 170, 3,               // 3014:         decode to t2PLDs using decoder 426
                                             // 3014:        } else try {
  OPC_CheckPredicate, 9,                     // 3019:         check predicate 9
  OPC_Decode, 172, 32, 170, 3,               // 3021:         decode to t2LDRBs using decoder 426
                                             // 3021:        }
                                             // 3021:       }
  2, 11,                                     // 3026:       case 0x2: {
  OPC_CheckPredicate, 9,                     // 3028:        check predicate 9
  OPC_CheckField, 8, 1, 1,                   // 3030:        check Inst[8] == 0x1
  OPC_Decode, 167, 32, 166, 3,               // 3034:        decode to t2LDRB_POST using decoder 422
                                             // 3034:       }
  3, 0,                                      // 3039:       case 0x3: {
  OPC_SwitchField, 8, 1,                     // 3041:        switch Inst[8] {
  0, 34,                                     // 3044:        case 0x0: {
  OPC_Scope, 25,                             // 3046:         try {
  OPC_SwitchField, 9, 1,                     // 3048:          switch Inst[9] {
  0, 11,                                     // 3051:          case 0x0: {
  OPC_CheckPredicate, 9,                     // 3053:           check predicate 9
  OPC_CheckField, 12, 4, 15,                 // 3055:           check Inst[15:12] == 0xf
  OPC_Decode, 255, 32, 171, 3,               // 3059:           decode to t2PLDi8 using decoder 427
                                             // 3059:          }
  1, 0,                                      // 3064:          case 0x1: {
  OPC_CheckPredicate, 9,                     // 3066:           check predicate 9
  OPC_Decode, 166, 32, 172, 3,               // 3068:           decode to t2LDRBT using decoder 428
                                             // 3068:          }
                                             // 3068:          } // switch Inst[9]
                                             // 3068:         } else try {
  OPC_CheckPredicate, 9,                     // 3073:          check predicate 9
  OPC_Decode, 170, 32, 171, 3,               // 3075:          decode to t2LDRBi8 using decoder 427
                                             // 3075:         }
                                             // 3075:        }
  1, 0,                                      // 3080:        case 0x1: {
  OPC_CheckPredicate, 9,                     // 3082:         check predicate 9
  OPC_Decode, 168, 32, 166, 3,               // 3084:         decode to t2LDRB_PRE using decoder 422
                                             // 3084:        }
                                             // 3084:        } // switch Inst[8]
                                             // 3084:       }
                                             // 3084:       } // switch Inst[11:10]
                                             // 3084:      }
  1, 0,                                      // 3089:      case 0x1: {
  OPC_Scope, 11,                             // 3091:       try {
  OPC_CheckField, 12, 4, 15,                 // 3093:        check Inst[15:12] == 0xf
  OPC_CheckPredicate, 9,                     // 3097:        check predicate 9
  OPC_Decode, 254, 32, 173, 3,               // 3099:        decode to t2PLDi12 using decoder 429
                                             // 3099:       } else try {
  OPC_CheckPredicate, 9,                     // 3104:        check predicate 9
  OPC_Decode, 169, 32, 173, 3,               // 3106:        decode to t2LDRBi12 using decoder 429
                                             // 3106:       }
                                             // 3106:      }
                                             // 3106:      } // switch Inst[23]
                                             // 3106:     } else try {
  OPC_CheckField, 16, 4, 15,                 // 3111:      check Inst[19:16] == 0xf
  OPC_Scope, 11,                             // 3115:      try {
  OPC_CheckField, 12, 4, 15,                 // 3117:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 9,                     // 3121:       check predicate 9
  OPC_Decode, 128, 33, 174, 3,               // 3123:       decode to t2PLDpci using decoder 430
                                             // 3123:      } else try {
  OPC_CheckPredicate, 9,                     // 3128:       check predicate 9
  OPC_Decode, 171, 32, 174, 3,               // 3130:       decode to t2LDRBpci using decoder 430
                                             // 3130:      }
                                             // 3130:     }
                                             // 3130:    }
                                             // 3130:    } // switch Inst[20]
                                             // 3130:   }
  1, 149, 1,                                 // 3135:   case 0x1: {
  OPC_CheckField, 20, 1, 1,                  // 3138:    check Inst[20] == 0x1
  OPC_Scope, 119,                            // 3142:    try {
  OPC_SwitchField, 23, 1,                    // 3144:     switch Inst[23] {
  0, 92,                                     // 3147:     case 0x0: {
  OPC_SwitchField, 10, 2,                    // 3149:      switch Inst[11:10] {
  0, 24,                                     // 3152:      case 0x0: {
  OPC_CheckField, 6, 4, 0,                   // 3154:       check Inst[9:6] == 0x0
  OPC_Scope, 11,                             // 3158:       try {
  OPC_CheckField, 12, 4, 15,                 // 3160:        check Inst[15:12] == 0xf
  OPC_CheckPredicate, 64,                    // 3164:        check predicate 64
  OPC_Decode, 133, 33, 170, 3,               // 3166:        decode to t2PLIs using decoder 426
                                             // 3166:       } else try {
  OPC_CheckPredicate, 9,                     // 3171:        check predicate 9
  OPC_Decode, 193, 32, 170, 3,               // 3173:        decode to t2LDRSBs using decoder 426
                                             // 3173:       }
                                             // 3173:      }
  2, 11,                                     // 3178:      case 0x2: {
  OPC_CheckPredicate, 9,                     // 3180:       check predicate 9
  OPC_CheckField, 8, 1, 1,                   // 3182:       check Inst[8] == 0x1
  OPC_Decode, 188, 32, 166, 3,               // 3186:       decode to t2LDRSB_POST using decoder 422
                                             // 3186:      }
  3, 0,                                      // 3191:      case 0x3: {
  OPC_SwitchField, 8, 1,                     // 3193:       switch Inst[8] {
  0, 34,                                     // 3196:       case 0x0: {
  OPC_Scope, 25,                             // 3198:        try {
  OPC_SwitchField, 9, 1,                     // 3200:         switch Inst[9] {
  0, 11,                                     // 3203:         case 0x0: {
  OPC_CheckPredicate, 64,                    // 3205:          check predicate 64
  OPC_CheckField, 12, 4, 15,                 // 3207:          check Inst[15:12] == 0xf
  OPC_Decode, 131, 33, 171, 3,               // 3211:          decode to t2PLIi8 using decoder 427
                                             // 3211:         }
  1, 0,                                      // 3216:         case 0x1: {
  OPC_CheckPredicate, 9,                     // 3218:          check predicate 9
  OPC_Decode, 187, 32, 172, 3,               // 3220:          decode to t2LDRSBT using decoder 428
                                             // 3220:         }
                                             // 3220:         } // switch Inst[9]
                                             // 3220:        } else try {
  OPC_CheckPredicate, 9,                     // 3225:         check predicate 9
  OPC_Decode, 191, 32, 171, 3,               // 3227:         decode to t2LDRSBi8 using decoder 427
                                             // 3227:        }
                                             // 3227:       }
  1, 0,                                      // 3232:       case 0x1: {
  OPC_CheckPredicate, 9,                     // 3234:        check predicate 9
  OPC_Decode, 189, 32, 166, 3,               // 3236:        decode to t2LDRSB_PRE using decoder 422
                                             // 3236:       }
                                             // 3236:       } // switch Inst[8]
                                             // 3236:      }
                                             // 3236:      } // switch Inst[11:10]
                                             // 3236:     }
  1, 0,                                      // 3241:     case 0x1: {
  OPC_Scope, 11,                             // 3243:      try {
  OPC_CheckField, 12, 4, 15,                 // 3245:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 64,                    // 3249:       check predicate 64
  OPC_Decode, 130, 33, 173, 3,               // 3251:       decode to t2PLIi12 using decoder 429
                                             // 3251:      } else try {
  OPC_CheckPredicate, 9,                     // 3256:       check predicate 9
  OPC_Decode, 190, 32, 173, 3,               // 3258:       decode to t2LDRSBi12 using decoder 429
                                             // 3258:      }
                                             // 3258:     }
                                             // 3258:     } // switch Inst[23]
                                             // 3258:    } else try {
  OPC_CheckField, 16, 4, 15,                 // 3263:     check Inst[19:16] == 0xf
  OPC_Scope, 11,                             // 3267:     try {
  OPC_CheckField, 12, 4, 15,                 // 3269:      check Inst[15:12] == 0xf
  OPC_CheckPredicate, 64,                    // 3273:      check predicate 64
  OPC_Decode, 132, 33, 174, 3,               // 3275:      decode to t2PLIpci using decoder 430
                                             // 3275:     } else try {
  OPC_CheckPredicate, 9,                     // 3280:      check predicate 9
  OPC_Decode, 192, 32, 174, 3,               // 3282:      decode to t2LDRSBpci using decoder 430
                                             // 3282:     }
                                             // 3282:    }
                                             // 3282:   }
  2, 178, 3,                                 // 3287:   case 0x2: {
  OPC_SwitchField, 7, 1,                     // 3290:    switch Inst[7] {
  0, 247, 1,                                 // 3293:    case 0x0: {
  OPC_SwitchField, 4, 3,                     // 3296:     switch Inst[6:4] {
  0, 47,                                     // 3299:     case 0x0: {
  OPC_SwitchField, 23, 1,                    // 3301:      switch Inst[23] {
  0, 11,                                     // 3304:      case 0x0: {
  OPC_CheckPredicate, 9,                     // 3306:       check predicate 9
  OPC_CheckField, 12, 4, 15,                 // 3308:       check Inst[15:12] == 0xf
  OPC_Decode, 211, 32, 230, 2,               // 3312:       decode to t2LSLrr using decoder 358
                                             // 3312:      }
  1, 0,                                      // 3317:      case 0x1: {
  OPC_SwitchField, 20, 1,                    // 3319:       switch Inst[20] {
  0, 11,                                     // 3322:       case 0x0: {
  OPC_CheckPredicate, 52,                    // 3324:        check predicate 52
  OPC_CheckField, 12, 4, 15,                 // 3326:        check Inst[15:12] == 0xf
  OPC_Decode, 159, 33, 175, 3,               // 3330:        decode to t2SADD8 using decoder 431
                                             // 3330:       }
  1, 0,                                      // 3335:       case 0x1: {
  OPC_CheckPredicate, 52,                    // 3337:        check predicate 52
  OPC_CheckField, 12, 4, 15,                 // 3339:        check Inst[15:12] == 0xf
  OPC_Decode, 158, 33, 175, 3,               // 3343:        decode to t2SADD16 using decoder 431
                                             // 3343:       }
                                             // 3343:       } // switch Inst[20]
                                             // 3343:      }
                                             // 3343:      } // switch Inst[23]
                                             // 3343:     }
  1, 37,                                     // 3348:     case 0x1: {
  OPC_SwitchField, 20, 1,                    // 3350:      switch Inst[20] {
  0, 15,                                     // 3353:      case 0x0: {
  OPC_CheckPredicate, 52,                    // 3355:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 3357:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3361:       check Inst[15:12] == 0xf
  OPC_Decode, 136, 33, 175, 3,               // 3365:       decode to t2QADD8 using decoder 431
                                             // 3365:      }
  1, 0,                                      // 3370:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 3372:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 3374:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3378:       check Inst[15:12] == 0xf
  OPC_Decode, 135, 33, 175, 3,               // 3382:       decode to t2QADD16 using decoder 431
                                             // 3382:      }
                                             // 3382:      } // switch Inst[20]
                                             // 3382:     }
  2, 37,                                     // 3387:     case 0x2: {
  OPC_SwitchField, 20, 1,                    // 3389:      switch Inst[20] {
  0, 15,                                     // 3392:      case 0x0: {
  OPC_CheckPredicate, 52,                    // 3394:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 3396:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3400:       check Inst[15:12] == 0xf
  OPC_Decode, 171, 33, 175, 3,               // 3404:       decode to t2SHADD8 using decoder 431
                                             // 3404:      }
  1, 0,                                      // 3409:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 3411:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 3413:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3417:       check Inst[15:12] == 0xf
  OPC_Decode, 170, 33, 175, 3,               // 3421:       decode to t2SHADD16 using decoder 431
                                             // 3421:      }
                                             // 3421:      } // switch Inst[20]
                                             // 3421:     }
  4, 37,                                     // 3426:     case 0x4: {
  OPC_SwitchField, 20, 1,                    // 3428:      switch Inst[20] {
  0, 15,                                     // 3431:      case 0x0: {
  OPC_CheckPredicate, 52,                    // 3433:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 3435:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3439:       check Inst[15:12] == 0xf
  OPC_Decode, 173, 34, 175, 3,               // 3443:       decode to t2UADD8 using decoder 431
                                             // 3443:      }
  1, 0,                                      // 3448:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 3450:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 3452:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3456:       check Inst[15:12] == 0xf
  OPC_Decode, 172, 34, 175, 3,               // 3460:       decode to t2UADD16 using decoder 431
                                             // 3460:      }
                                             // 3460:      } // switch Inst[20]
                                             // 3460:     }
  5, 37,                                     // 3465:     case 0x5: {
  OPC_SwitchField, 20, 1,                    // 3467:      switch Inst[20] {
  0, 15,                                     // 3470:      case 0x0: {
  OPC_CheckPredicate, 52,                    // 3472:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 3474:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3478:       check Inst[15:12] == 0xf
  OPC_Decode, 188, 34, 175, 3,               // 3482:       decode to t2UQADD8 using decoder 431
                                             // 3482:      }
  1, 0,                                      // 3487:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 3489:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 3491:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3495:       check Inst[15:12] == 0xf
  OPC_Decode, 187, 34, 175, 3,               // 3499:       decode to t2UQADD16 using decoder 431
                                             // 3499:      }
                                             // 3499:      } // switch Inst[20]
                                             // 3499:     }
  6, 0,                                      // 3504:     case 0x6: {
  OPC_SwitchField, 20, 1,                    // 3506:      switch Inst[20] {
  0, 15,                                     // 3509:      case 0x0: {
  OPC_CheckPredicate, 52,                    // 3511:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 3513:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3517:       check Inst[15:12] == 0xf
  OPC_Decode, 179, 34, 175, 3,               // 3521:       decode to t2UHADD8 using decoder 431
                                             // 3521:      }
  1, 0,                                      // 3526:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 3528:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 3530:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3534:       check Inst[15:12] == 0xf
  OPC_Decode, 178, 34, 175, 3,               // 3538:       decode to t2UHADD16 using decoder 431
                                             // 3538:      }
                                             // 3538:      } // switch Inst[20]
                                             // 3538:     }
                                             // 3538:     } // switch Inst[6:4]
                                             // 3538:    }
  1, 0,                                      // 3543:    case 0x1: {
  OPC_SwitchField, 20, 1,                    // 3545:     switch Inst[20] {
  0, 86,                                     // 3548:     case 0x0: {
  OPC_SwitchField, 23, 1,                    // 3550:      switch Inst[23] {
  0, 24,                                     // 3553:      case 0x0: {
  OPC_CheckField, 12, 4, 15,                 // 3555:       check Inst[15:12] == 0xf
  OPC_Scope, 11,                             // 3559:       try {
  OPC_CheckField, 16, 4, 15,                 // 3561:        check Inst[19:16] == 0xf
  OPC_CheckPredicate, 9,                     // 3565:        check predicate 9
  OPC_Decode, 158, 34, 176, 3,               // 3567:        decode to t2SXTH using decoder 432
                                             // 3567:       } else try {
  OPC_CheckPredicate, 50,                    // 3572:        check predicate 50
  OPC_Decode, 155, 34, 177, 3,               // 3574:        decode to t2SXTAH using decoder 433
                                             // 3574:       }
                                             // 3574:      }
  1, 0,                                      // 3579:      case 0x1: {
  OPC_SwitchField, 4, 3,                     // 3581:       switch Inst[6:4] {
  0, 11,                                     // 3584:       case 0x0: {
  OPC_CheckPredicate, 52,                    // 3586:        check predicate 52
  OPC_CheckField, 12, 4, 15,                 // 3588:        check Inst[15:12] == 0xf
  OPC_Decode, 134, 33, 178, 3,               // 3592:        decode to t2QADD using decoder 434
                                             // 3592:       }
  1, 11,                                     // 3597:       case 0x1: {
  OPC_CheckPredicate, 52,                    // 3599:        check predicate 52
  OPC_CheckField, 12, 4, 15,                 // 3601:        check Inst[15:12] == 0xf
  OPC_Decode, 138, 33, 178, 3,               // 3605:        decode to t2QDADD using decoder 434
                                             // 3605:       }
  2, 11,                                     // 3610:       case 0x2: {
  OPC_CheckPredicate, 52,                    // 3612:        check predicate 52
  OPC_CheckField, 12, 4, 15,                 // 3614:        check Inst[15:12] == 0xf
  OPC_Decode, 141, 33, 178, 3,               // 3618:        decode to t2QSUB using decoder 434
                                             // 3618:       }
  3, 0,                                      // 3623:       case 0x3: {
  OPC_CheckPredicate, 52,                    // 3625:        check predicate 52
  OPC_CheckField, 12, 4, 15,                 // 3627:        check Inst[15:12] == 0xf
  OPC_Decode, 139, 33, 178, 3,               // 3631:        decode to t2QDSUB using decoder 434
                                             // 3631:       }
                                             // 3631:       } // switch Inst[6:4]
                                             // 3631:      }
                                             // 3631:      } // switch Inst[23]
                                             // 3631:     }
  1, 0,                                      // 3636:     case 0x1: {
  OPC_SwitchField, 23, 1,                    // 3638:      switch Inst[23] {
  0, 24,                                     // 3641:      case 0x0: {
  OPC_CheckField, 12, 4, 15,                 // 3643:       check Inst[15:12] == 0xf
  OPC_Scope, 11,                             // 3647:       try {
  OPC_CheckField, 16, 4, 15,                 // 3649:        check Inst[19:16] == 0xf
  OPC_CheckPredicate, 9,                     // 3653:        check predicate 9
  OPC_Decode, 205, 34, 176, 3,               // 3655:        decode to t2UXTH using decoder 432
                                             // 3655:       } else try {
  OPC_CheckPredicate, 50,                    // 3660:        check predicate 50
  OPC_Decode, 202, 34, 177, 3,               // 3662:        decode to t2UXTAH using decoder 433
                                             // 3662:       }
                                             // 3662:      }
  1, 0,                                      // 3667:      case 0x1: {
  OPC_SwitchField, 4, 3,                     // 3669:       switch Inst[6:4] {
  0, 11,                                     // 3672:       case 0x0: {
  OPC_CheckPredicate, 9,                     // 3674:        check predicate 9
  OPC_CheckField, 12, 4, 15,                 // 3676:        check Inst[15:12] == 0xf
  OPC_Decode, 145, 33, 179, 3,               // 3680:        decode to t2REV using decoder 435
                                             // 3680:       }
  1, 11,                                     // 3685:       case 0x1: {
  OPC_CheckPredicate, 9,                     // 3687:        check predicate 9
  OPC_CheckField, 12, 4, 15,                 // 3689:        check Inst[15:12] == 0xf
  OPC_Decode, 146, 33, 179, 3,               // 3693:        decode to t2REV16 using decoder 435
                                             // 3693:       }
  2, 11,                                     // 3698:       case 0x2: {
  OPC_CheckPredicate, 9,                     // 3700:        check predicate 9
  OPC_CheckField, 12, 4, 15,                 // 3702:        check Inst[15:12] == 0xf
  OPC_Decode, 144, 33, 179, 3,               // 3706:        decode to t2RBIT using decoder 435
                                             // 3706:       }
  3, 0,                                      // 3711:       case 0x3: {
  OPC_CheckPredicate, 9,                     // 3713:        check predicate 9
  OPC_CheckField, 12, 4, 15,                 // 3715:        check Inst[15:12] == 0xf
  OPC_Decode, 147, 33, 179, 3,               // 3719:        decode to t2REVSH using decoder 435
                                             // 3719:       }
                                             // 3719:       } // switch Inst[6:4]
                                             // 3719:      }
                                             // 3719:      } // switch Inst[23]
                                             // 3719:     }
                                             // 3719:     } // switch Inst[20]
                                             // 3719:    }
                                             // 3719:    } // switch Inst[7]
                                             // 3719:   }
  3, 0,                                      // 3724:   case 0x3: {
  OPC_SwitchField, 4, 4,                     // 3726:    switch Inst[7:4] {
  0, 65,                                     // 3729:    case 0x0: {
  OPC_SwitchField, 20, 1,                    // 3731:     switch Inst[20] {
  0, 34,                                     // 3734:     case 0x0: {
  OPC_SwitchField, 23, 1,                    // 3736:      switch Inst[23] {
  0, 20,                                     // 3739:      case 0x0: {
  OPC_Scope, 11,                             // 3741:       try {
  OPC_CheckField, 12, 4, 15,                 // 3743:        check Inst[15:12] == 0xf
  OPC_CheckPredicate, 9,                     // 3747:        check predicate 9
  OPC_Decode, 236, 32, 175, 3,               // 3749:        decode to t2MUL using decoder 431
                                             // 3749:       } else try {
  OPC_CheckPredicate, 9,                     // 3754:        check predicate 9
  OPC_Decode, 219, 32, 180, 3,               // 3756:        decode to t2MLA using decoder 436
                                             // 3756:       }
                                             // 3756:      }
  1, 0,                                      // 3761:      case 0x1: {
  OPC_CheckPredicate, 9,                     // 3763:       check predicate 9
  OPC_Decode, 206, 33, 181, 3,               // 3765:       decode to t2SMULL using decoder 437
                                             // 3765:      }
                                             // 3765:      } // switch Inst[23]
                                             // 3765:     }
  1, 0,                                      // 3770:     case 0x1: {
  OPC_CheckField, 23, 1, 0,                  // 3772:      check Inst[23] == 0x0
  OPC_Scope, 11,                             // 3776:      try {
  OPC_CheckField, 12, 4, 15,                 // 3778:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 3782:       check predicate 52
  OPC_Decode, 204, 33, 175, 3,               // 3784:       decode to t2SMULBB using decoder 431
                                             // 3784:      } else try {
  OPC_CheckPredicate, 52,                    // 3789:       check predicate 52
  OPC_Decode, 177, 33, 180, 3,               // 3791:       decode to t2SMLABB using decoder 436
                                             // 3791:      }
                                             // 3791:     }
                                             // 3791:     } // switch Inst[20]
                                             // 3791:    }
  1, 42,                                     // 3796:    case 0x1: {
  OPC_SwitchField, 20, 1,                    // 3798:     switch Inst[20] {
  0, 11,                                     // 3801:     case 0x0: {
  OPC_CheckPredicate, 9,                     // 3803:      check predicate 9
  OPC_CheckField, 23, 1, 0,                  // 3805:      check Inst[23] == 0x0
  OPC_Decode, 220, 32, 180, 3,               // 3809:      decode to t2MLS using decoder 436
                                             // 3809:     }
  1, 0,                                      // 3814:     case 0x1: {
  OPC_CheckField, 23, 1, 0,                  // 3816:      check Inst[23] == 0x0
  OPC_Scope, 11,                             // 3820:      try {
  OPC_CheckField, 12, 4, 15,                 // 3822:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 3826:       check predicate 52
  OPC_Decode, 205, 33, 175, 3,               // 3828:       decode to t2SMULBT using decoder 431
                                             // 3828:      } else try {
  OPC_CheckPredicate, 52,                    // 3833:       check predicate 52
  OPC_Decode, 178, 33, 180, 3,               // 3835:       decode to t2SMLABT using decoder 436
                                             // 3835:      }
                                             // 3835:     }
                                             // 3835:     } // switch Inst[20]
                                             // 3835:    }
  2, 28,                                     // 3840:    case 0x2: {
  OPC_CheckField, 20, 1, 1,                  // 3842:     check Inst[20] == 0x1
  OPC_CheckField, 23, 1, 0,                  // 3846:     check Inst[23] == 0x0
  OPC_Scope, 11,                             // 3850:     try {
  OPC_CheckField, 12, 4, 15,                 // 3852:      check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 3856:      check predicate 52
  OPC_Decode, 207, 33, 175, 3,               // 3858:      decode to t2SMULTB using decoder 431
                                             // 3858:     } else try {
  OPC_CheckPredicate, 52,                    // 3863:      check predicate 52
  OPC_Decode, 188, 33, 180, 3,               // 3865:      decode to t2SMLATB using decoder 436
                                             // 3865:     }
                                             // 3865:    }
  3, 28,                                     // 3870:    case 0x3: {
  OPC_CheckField, 20, 1, 1,                  // 3872:     check Inst[20] == 0x1
  OPC_CheckField, 23, 1, 0,                  // 3876:     check Inst[23] == 0x0
  OPC_Scope, 11,                             // 3880:     try {
  OPC_CheckField, 12, 4, 15,                 // 3882:      check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 3886:      check predicate 52
  OPC_Decode, 208, 33, 175, 3,               // 3888:      decode to t2SMULTT using decoder 431
                                             // 3888:     } else try {
  OPC_CheckPredicate, 52,                    // 3893:      check predicate 52
  OPC_Decode, 189, 33, 180, 3,               // 3895:      decode to t2SMLATT using decoder 436
                                             // 3895:     }
                                             // 3895:    }
  15, 0,                                     // 3900:    case 0xf: {
  OPC_CheckPredicate, 65,                    // 3902:     check predicate 65
  OPC_CheckField, 23, 1, 1,                  // 3904:     check Inst[23] == 0x1
  OPC_CheckField, 20, 1, 1,                  // 3908:     check Inst[20] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 3912:     check Inst[15:12] == 0xf
  OPC_Decode, 166, 33, 175, 3,               // 3916:     decode to t2SDIV using decoder 431
                                             // 3916:    }
                                             // 3916:    } // switch Inst[7:4]
                                             // 3916:   }
                                             // 3916:   } // switch Inst[26:24]
                                             // 3916:  }
  1, 213, 5,                                 // 3921:  case 0x1: {
  OPC_SwitchField, 24, 3,                    // 3924:   switch Inst[26:24] {
  0, 218, 1,                                 // 3927:   case 0x0: {
  OPC_SwitchField, 20, 1,                    // 3930:    switch Inst[20] {
  0, 79,                                     // 3933:    case 0x0: {
  OPC_SwitchField, 23, 1,                    // 3935:     switch Inst[23] {
  0, 65,                                     // 3938:     case 0x0: {
  OPC_SwitchField, 10, 2,                    // 3940:      switch Inst[11:10] {
  0, 11,                                     // 3943:      case 0x0: {
  OPC_CheckPredicate, 9,                     // 3945:       check predicate 9
  OPC_CheckField, 6, 4, 0,                   // 3947:       check Inst[9:6] == 0x0
  OPC_Decode, 139, 34, 165, 3,               // 3951:       decode to t2STRHs using decoder 421
                                             // 3951:      }
  2, 11,                                     // 3956:      case 0x2: {
  OPC_CheckPredicate, 9,                     // 3958:       check predicate 9
  OPC_CheckField, 8, 1, 1,                   // 3960:       check Inst[8] == 0x1
  OPC_Decode, 135, 34, 166, 3,               // 3964:       decode to t2STRH_POST using decoder 422
                                             // 3964:      }
  3, 0,                                      // 3969:      case 0x3: {
  OPC_SwitchField, 8, 1,                     // 3971:       switch Inst[8] {
  0, 20,                                     // 3974:       case 0x0: {
  OPC_Scope, 11,                             // 3976:        try {
  OPC_CheckField, 9, 1, 1,                   // 3978:         check Inst[9] == 0x1
  OPC_CheckPredicate, 9,                     // 3982:         check predicate 9
  OPC_Decode, 134, 34, 167, 3,               // 3984:         decode to t2STRHT using decoder 423
                                             // 3984:        } else try {
  OPC_CheckPredicate, 9,                     // 3989:         check predicate 9
  OPC_Decode, 138, 34, 168, 3,               // 3991:         decode to t2STRHi8 using decoder 424
                                             // 3991:        }
                                             // 3991:       }
  1, 0,                                      // 3996:       case 0x1: {
  OPC_CheckPredicate, 9,                     // 3998:        check predicate 9
  OPC_Decode, 136, 34, 166, 3,               // 4000:        decode to t2STRH_PRE using decoder 422
                                             // 4000:       }
                                             // 4000:       } // switch Inst[8]
                                             // 4000:      }
                                             // 4000:      } // switch Inst[11:10]
                                             // 4000:     }
  1, 0,                                      // 4005:     case 0x1: {
  OPC_CheckPredicate, 9,                     // 4007:      check predicate 9
  OPC_Decode, 137, 34, 169, 3,               // 4009:      decode to t2STRHi12 using decoder 425
                                             // 4009:     }
                                             // 4009:     } // switch Inst[23]
                                             // 4009:    }
  1, 0,                                      // 4014:    case 0x1: {
  OPC_Scope, 119,                            // 4016:     try {
  OPC_SwitchField, 23, 1,                    // 4018:      switch Inst[23] {
  0, 92,                                     // 4021:      case 0x0: {
  OPC_SwitchField, 10, 2,                    // 4023:       switch Inst[11:10] {
  0, 24,                                     // 4026:       case 0x0: {
  OPC_CheckField, 6, 4, 0,                   // 4028:        check Inst[9:6] == 0x0
  OPC_Scope, 11,                             // 4032:        try {
  OPC_CheckField, 12, 4, 15,                 // 4034:         check Inst[15:12] == 0xf
  OPC_CheckPredicate, 66,                    // 4038:         check predicate 66
  OPC_Decode, 253, 32, 170, 3,               // 4040:         decode to t2PLDWs using decoder 426
                                             // 4040:        } else try {
  OPC_CheckPredicate, 9,                     // 4045:         check predicate 9
  OPC_Decode, 186, 32, 170, 3,               // 4047:         decode to t2LDRHs using decoder 426
                                             // 4047:        }
                                             // 4047:       }
  2, 11,                                     // 4052:       case 0x2: {
  OPC_CheckPredicate, 9,                     // 4054:        check predicate 9
  OPC_CheckField, 8, 1, 1,                   // 4056:        check Inst[8] == 0x1
  OPC_Decode, 181, 32, 166, 3,               // 4060:        decode to t2LDRH_POST using decoder 422
                                             // 4060:       }
  3, 0,                                      // 4065:       case 0x3: {
  OPC_SwitchField, 8, 1,                     // 4067:        switch Inst[8] {
  0, 34,                                     // 4070:        case 0x0: {
  OPC_Scope, 25,                             // 4072:         try {
  OPC_SwitchField, 9, 1,                     // 4074:          switch Inst[9] {
  0, 11,                                     // 4077:          case 0x0: {
  OPC_CheckPredicate, 66,                    // 4079:           check predicate 66
  OPC_CheckField, 12, 4, 15,                 // 4081:           check Inst[15:12] == 0xf
  OPC_Decode, 252, 32, 171, 3,               // 4085:           decode to t2PLDWi8 using decoder 427
                                             // 4085:          }
  1, 0,                                      // 4090:          case 0x1: {
  OPC_CheckPredicate, 9,                     // 4092:           check predicate 9
  OPC_Decode, 180, 32, 172, 3,               // 4094:           decode to t2LDRHT using decoder 428
                                             // 4094:          }
                                             // 4094:          } // switch Inst[9]
                                             // 4094:         } else try {
  OPC_CheckPredicate, 9,                     // 4099:          check predicate 9
  OPC_Decode, 184, 32, 171, 3,               // 4101:          decode to t2LDRHi8 using decoder 427
                                             // 4101:         }
                                             // 4101:        }
  1, 0,                                      // 4106:        case 0x1: {
  OPC_CheckPredicate, 9,                     // 4108:         check predicate 9
  OPC_Decode, 182, 32, 166, 3,               // 4110:         decode to t2LDRH_PRE using decoder 422
                                             // 4110:        }
                                             // 4110:        } // switch Inst[8]
                                             // 4110:       }
                                             // 4110:       } // switch Inst[11:10]
                                             // 4110:      }
  1, 0,                                      // 4115:      case 0x1: {
  OPC_Scope, 11,                             // 4117:       try {
  OPC_CheckField, 12, 4, 15,                 // 4119:        check Inst[15:12] == 0xf
  OPC_CheckPredicate, 66,                    // 4123:        check predicate 66
  OPC_Decode, 251, 32, 173, 3,               // 4125:        decode to t2PLDWi12 using decoder 429
                                             // 4125:       } else try {
  OPC_CheckPredicate, 9,                     // 4130:        check predicate 9
  OPC_Decode, 183, 32, 173, 3,               // 4132:        decode to t2LDRHi12 using decoder 429
                                             // 4132:       }
                                             // 4132:      }
                                             // 4132:      } // switch Inst[23]
                                             // 4132:     } else try {
  OPC_CheckPredicate, 9,                     // 4137:      check predicate 9
  OPC_CheckField, 16, 4, 15,                 // 4139:      check Inst[19:16] == 0xf
  OPC_Decode, 185, 32, 174, 3,               // 4143:      decode to t2LDRHpci using decoder 430
                                             // 4143:     }
                                             // 4143:    }
                                             // 4143:    } // switch Inst[20]
                                             // 4143:   }
  1, 96,                                     // 4148:   case 0x1: {
  OPC_CheckField, 20, 1, 1,                  // 4150:    check Inst[20] == 0x1
  OPC_Scope, 79,                             // 4154:    try {
  OPC_SwitchField, 23, 1,                    // 4156:     switch Inst[23] {
  0, 65,                                     // 4159:     case 0x0: {
  OPC_SwitchField, 10, 2,                    // 4161:      switch Inst[11:10] {
  0, 11,                                     // 4164:      case 0x0: {
  OPC_CheckPredicate, 9,                     // 4166:       check predicate 9
  OPC_CheckField, 6, 4, 0,                   // 4168:       check Inst[9:6] == 0x0
  OPC_Decode, 200, 32, 170, 3,               // 4172:       decode to t2LDRSHs using decoder 426
                                             // 4172:      }
  2, 11,                                     // 4177:      case 0x2: {
  OPC_CheckPredicate, 9,                     // 4179:       check predicate 9
  OPC_CheckField, 8, 1, 1,                   // 4181:       check Inst[8] == 0x1
  OPC_Decode, 195, 32, 166, 3,               // 4185:       decode to t2LDRSH_POST using decoder 422
                                             // 4185:      }
  3, 0,                                      // 4190:      case 0x3: {
  OPC_SwitchField, 8, 1,                     // 4192:       switch Inst[8] {
  0, 20,                                     // 4195:       case 0x0: {
  OPC_Scope, 11,                             // 4197:        try {
  OPC_CheckField, 9, 1, 1,                   // 4199:         check Inst[9] == 0x1
  OPC_CheckPredicate, 9,                     // 4203:         check predicate 9
  OPC_Decode, 194, 32, 172, 3,               // 4205:         decode to t2LDRSHT using decoder 428
                                             // 4205:        } else try {
  OPC_CheckPredicate, 9,                     // 4210:         check predicate 9
  OPC_Decode, 198, 32, 171, 3,               // 4212:         decode to t2LDRSHi8 using decoder 427
                                             // 4212:        }
                                             // 4212:       }
  1, 0,                                      // 4217:       case 0x1: {
  OPC_CheckPredicate, 9,                     // 4219:        check predicate 9
  OPC_Decode, 196, 32, 166, 3,               // 4221:        decode to t2LDRSH_PRE using decoder 422
                                             // 4221:       }
                                             // 4221:       } // switch Inst[8]
                                             // 4221:      }
                                             // 4221:      } // switch Inst[11:10]
                                             // 4221:     }
  1, 0,                                      // 4226:     case 0x1: {
  OPC_CheckPredicate, 9,                     // 4228:      check predicate 9
  OPC_Decode, 197, 32, 173, 3,               // 4230:      decode to t2LDRSHi12 using decoder 429
                                             // 4230:     }
                                             // 4230:     } // switch Inst[23]
                                             // 4230:    } else try {
  OPC_CheckPredicate, 9,                     // 4235:     check predicate 9
  OPC_CheckField, 16, 4, 15,                 // 4237:     check Inst[19:16] == 0xf
  OPC_Decode, 199, 32, 174, 3,               // 4241:     decode to t2LDRSHpci using decoder 430
                                             // 4241:    }
                                             // 4241:   }
  2, 250, 1,                                 // 4246:   case 0x2: {
  OPC_SwitchField, 7, 1,                     // 4249:    switch Inst[7] {
  0, 143, 1,                                 // 4252:    case 0x0: {
  OPC_SwitchField, 4, 3,                     // 4255:     switch Inst[6:4] {
  0, 33,                                     // 4258:     case 0x0: {
  OPC_SwitchField, 23, 1,                    // 4260:      switch Inst[23] {
  0, 11,                                     // 4263:      case 0x0: {
  OPC_CheckPredicate, 9,                     // 4265:       check predicate 9
  OPC_CheckField, 12, 4, 15,                 // 4267:       check Inst[15:12] == 0xf
  OPC_Decode, 213, 32, 230, 2,               // 4271:       decode to t2LSRrr using decoder 358
                                             // 4271:      }
  1, 0,                                      // 4276:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 4278:       check predicate 52
  OPC_CheckField, 20, 1, 0,                  // 4280:       check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 4284:       check Inst[15:12] == 0xf
  OPC_Decode, 160, 33, 175, 3,               // 4288:       decode to t2SASX using decoder 431
                                             // 4288:      }
                                             // 4288:      } // switch Inst[23]
                                             // 4288:     }
  1, 19,                                     // 4293:     case 0x1: {
  OPC_CheckPredicate, 52,                    // 4295:      check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 4297:      check Inst[23] == 0x1
  OPC_CheckField, 20, 1, 0,                  // 4301:      check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 4305:      check Inst[15:12] == 0xf
  OPC_Decode, 137, 33, 175, 3,               // 4309:      decode to t2QASX using decoder 431
                                             // 4309:     }
  2, 19,                                     // 4314:     case 0x2: {
  OPC_CheckPredicate, 52,                    // 4316:      check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 4318:      check Inst[23] == 0x1
  OPC_CheckField, 20, 1, 0,                  // 4322:      check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 4326:      check Inst[15:12] == 0xf
  OPC_Decode, 172, 33, 175, 3,               // 4330:      decode to t2SHASX using decoder 431
                                             // 4330:     }
  4, 19,                                     // 4335:     case 0x4: {
  OPC_CheckPredicate, 52,                    // 4337:      check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 4339:      check Inst[23] == 0x1
  OPC_CheckField, 20, 1, 0,                  // 4343:      check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 4347:      check Inst[15:12] == 0xf
  OPC_Decode, 174, 34, 175, 3,               // 4351:      decode to t2UASX using decoder 431
                                             // 4351:     }
  5, 19,                                     // 4356:     case 0x5: {
  OPC_CheckPredicate, 52,                    // 4358:      check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 4360:      check Inst[23] == 0x1
  OPC_CheckField, 20, 1, 0,                  // 4364:      check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 4368:      check Inst[15:12] == 0xf
  OPC_Decode, 189, 34, 175, 3,               // 4372:      decode to t2UQASX using decoder 431
                                             // 4372:     }
  6, 0,                                      // 4377:     case 0x6: {
  OPC_CheckPredicate, 52,                    // 4379:      check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 4381:      check Inst[23] == 0x1
  OPC_CheckField, 20, 1, 0,                  // 4385:      check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 4389:      check Inst[15:12] == 0xf
  OPC_Decode, 180, 34, 175, 3,               // 4393:      decode to t2UHASX using decoder 431
                                             // 4393:     }
                                             // 4393:     } // switch Inst[6:4]
                                             // 4393:    }
  1, 0,                                      // 4398:    case 0x1: {
  OPC_SwitchField, 20, 1,                    // 4400:     switch Inst[20] {
  0, 46,                                     // 4403:     case 0x0: {
  OPC_SwitchField, 23, 1,                    // 4405:      switch Inst[23] {
  0, 24,                                     // 4408:      case 0x0: {
  OPC_CheckField, 12, 4, 15,                 // 4410:       check Inst[15:12] == 0xf
  OPC_Scope, 11,                             // 4414:       try {
  OPC_CheckField, 16, 4, 15,                 // 4416:        check Inst[19:16] == 0xf
  OPC_CheckPredicate, 50,                    // 4420:        check predicate 50
  OPC_Decode, 157, 34, 176, 3,               // 4422:        decode to t2SXTB16 using decoder 432
                                             // 4422:       } else try {
  OPC_CheckPredicate, 50,                    // 4427:        check predicate 50
  OPC_Decode, 154, 34, 177, 3,               // 4429:        decode to t2SXTAB16 using decoder 433
                                             // 4429:       }
                                             // 4429:      }
  1, 0,                                      // 4434:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 4436:       check predicate 52
  OPC_CheckField, 12, 4, 15,                 // 4438:       check Inst[15:12] == 0xf
  OPC_CheckField, 4, 3, 0,                   // 4442:       check Inst[6:4] == 0x0
  OPC_Decode, 167, 33, 182, 3,               // 4446:       decode to t2SEL using decoder 438
                                             // 4446:      }
                                             // 4446:      } // switch Inst[23]
                                             // 4446:     }
  1, 0,                                      // 4451:     case 0x1: {
  OPC_SwitchField, 23, 1,                    // 4453:      switch Inst[23] {
  0, 24,                                     // 4456:      case 0x0: {
  OPC_CheckField, 12, 4, 15,                 // 4458:       check Inst[15:12] == 0xf
  OPC_Scope, 11,                             // 4462:       try {
  OPC_CheckField, 16, 4, 15,                 // 4464:        check Inst[19:16] == 0xf
  OPC_CheckPredicate, 50,                    // 4468:        check predicate 50
  OPC_Decode, 204, 34, 176, 3,               // 4470:        decode to t2UXTB16 using decoder 432
                                             // 4470:       } else try {
  OPC_CheckPredicate, 50,                    // 4475:        check predicate 50
  OPC_Decode, 201, 34, 177, 3,               // 4477:        decode to t2UXTAB16 using decoder 433
                                             // 4477:       }
                                             // 4477:      }
  1, 0,                                      // 4482:      case 0x1: {
  OPC_CheckPredicate, 9,                     // 4484:       check predicate 9
  OPC_CheckField, 12, 4, 15,                 // 4486:       check Inst[15:12] == 0xf
  OPC_CheckField, 4, 3, 0,                   // 4490:       check Inst[6:4] == 0x0
  OPC_Decode, 231, 31, 179, 3,               // 4494:       decode to t2CLZ using decoder 435
                                             // 4494:      }
                                             // 4494:      } // switch Inst[23]
                                             // 4494:     }
                                             // 4494:     } // switch Inst[20]
                                             // 4494:    }
                                             // 4494:    } // switch Inst[7]
                                             // 4494:   }
  3, 0,                                      // 4499:   case 0x3: {
  OPC_SwitchField, 4, 4,                     // 4501:    switch Inst[7:4] {
  0, 65,                                     // 4504:    case 0x0: {
  OPC_SwitchField, 20, 1,                    // 4506:     switch Inst[20] {
  0, 34,                                     // 4509:     case 0x0: {
  OPC_SwitchField, 23, 1,                    // 4511:      switch Inst[23] {
  0, 20,                                     // 4514:      case 0x0: {
  OPC_Scope, 11,                             // 4516:       try {
  OPC_CheckField, 12, 4, 15,                 // 4518:        check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 4522:        check predicate 52
  OPC_Decode, 202, 33, 175, 3,               // 4524:        decode to t2SMUAD using decoder 431
                                             // 4524:       } else try {
  OPC_CheckPredicate, 52,                    // 4529:        check predicate 52
  OPC_Decode, 179, 33, 180, 3,               // 4531:        decode to t2SMLAD using decoder 436
                                             // 4531:       }
                                             // 4531:      }
  1, 0,                                      // 4536:      case 0x1: {
  OPC_CheckPredicate, 9,                     // 4538:       check predicate 9
  OPC_Decode, 186, 34, 181, 3,               // 4540:       decode to t2UMULL using decoder 437
                                             // 4540:      }
                                             // 4540:      } // switch Inst[23]
                                             // 4540:     }
  1, 0,                                      // 4545:     case 0x1: {
  OPC_CheckField, 23, 1, 0,                  // 4547:      check Inst[23] == 0x0
  OPC_Scope, 11,                             // 4551:      try {
  OPC_CheckField, 12, 4, 15,                 // 4553:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 4557:       check predicate 52
  OPC_Decode, 209, 33, 175, 3,               // 4559:       decode to t2SMULWB using decoder 431
                                             // 4559:      } else try {
  OPC_CheckPredicate, 52,                    // 4564:       check predicate 52
  OPC_Decode, 190, 33, 180, 3,               // 4566:       decode to t2SMLAWB using decoder 436
                                             // 4566:      }
                                             // 4566:     }
                                             // 4566:     } // switch Inst[20]
                                             // 4566:    }
  1, 55,                                     // 4571:    case 0x1: {
  OPC_SwitchField, 20, 1,                    // 4573:     switch Inst[20] {
  0, 24,                                     // 4576:     case 0x0: {
  OPC_CheckField, 23, 1, 0,                  // 4578:      check Inst[23] == 0x0
  OPC_Scope, 11,                             // 4582:      try {
  OPC_CheckField, 12, 4, 15,                 // 4584:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 4588:       check predicate 52
  OPC_Decode, 203, 33, 175, 3,               // 4590:       decode to t2SMUADX using decoder 431
                                             // 4590:      } else try {
  OPC_CheckPredicate, 52,                    // 4595:       check predicate 52
  OPC_Decode, 180, 33, 180, 3,               // 4597:       decode to t2SMLADX using decoder 436
                                             // 4597:      }
                                             // 4597:     }
  1, 0,                                      // 4602:     case 0x1: {
  OPC_CheckField, 23, 1, 0,                  // 4604:      check Inst[23] == 0x0
  OPC_Scope, 11,                             // 4608:      try {
  OPC_CheckField, 12, 4, 15,                 // 4610:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 4614:       check predicate 52
  OPC_Decode, 210, 33, 175, 3,               // 4616:       decode to t2SMULWT using decoder 431
                                             // 4616:      } else try {
  OPC_CheckPredicate, 52,                    // 4621:       check predicate 52
  OPC_Decode, 191, 33, 180, 3,               // 4623:       decode to t2SMLAWT using decoder 436
                                             // 4623:      }
                                             // 4623:     }
                                             // 4623:     } // switch Inst[20]
                                             // 4623:    }
  15, 0,                                     // 4628:    case 0xf: {
  OPC_CheckPredicate, 65,                    // 4630:     check predicate 65
  OPC_CheckField, 23, 1, 1,                  // 4632:     check Inst[23] == 0x1
  OPC_CheckField, 20, 1, 1,                  // 4636:     check Inst[20] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 4640:     check Inst[15:12] == 0xf
  OPC_Decode, 177, 34, 175, 3,               // 4644:     decode to t2UDIV using decoder 431
                                             // 4644:    }
                                             // 4644:    } // switch Inst[7:4]
                                             // 4644:   }
                                             // 4644:   } // switch Inst[26:24]
                                             // 4644:  }
  2, 240, 6,                                 // 4649:  case 0x2: {
  OPC_SwitchField, 24, 3,                    // 4652:   switch Inst[26:24] {
  0, 178, 1,                                 // 4655:   case 0x0: {
  OPC_SwitchField, 20, 1,                    // 4658:    switch Inst[20] {
  0, 79,                                     // 4661:    case 0x0: {
  OPC_SwitchField, 23, 1,                    // 4663:     switch Inst[23] {
  0, 65,                                     // 4666:     case 0x0: {
  OPC_SwitchField, 10, 2,                    // 4668:      switch Inst[11:10] {
  0, 11,                                     // 4671:      case 0x0: {
  OPC_CheckPredicate, 9,                     // 4673:       check predicate 9
  OPC_CheckField, 6, 4, 0,                   // 4675:       check Inst[9:6] == 0x0
  OPC_Decode, 145, 34, 183, 3,               // 4679:       decode to t2STRs using decoder 439
                                             // 4679:      }
  2, 11,                                     // 4684:      case 0x2: {
  OPC_CheckPredicate, 9,                     // 4686:       check predicate 9
  OPC_CheckField, 8, 1, 1,                   // 4688:       check Inst[8] == 0x1
  OPC_Decode, 141, 34, 166, 3,               // 4692:       decode to t2STR_POST using decoder 422
                                             // 4692:      }
  3, 0,                                      // 4697:      case 0x3: {
  OPC_SwitchField, 8, 1,                     // 4699:       switch Inst[8] {
  0, 20,                                     // 4702:       case 0x0: {
  OPC_Scope, 11,                             // 4704:        try {
  OPC_CheckField, 9, 1, 1,                   // 4706:         check Inst[9] == 0x1
  OPC_CheckPredicate, 9,                     // 4710:         check predicate 9
  OPC_Decode, 140, 34, 167, 3,               // 4712:         decode to t2STRT using decoder 423
                                             // 4712:        } else try {
  OPC_CheckPredicate, 9,                     // 4717:         check predicate 9
  OPC_Decode, 144, 34, 184, 3,               // 4719:         decode to t2STRi8 using decoder 440
                                             // 4719:        }
                                             // 4719:       }
  1, 0,                                      // 4724:       case 0x1: {
  OPC_CheckPredicate, 9,                     // 4726:        check predicate 9
  OPC_Decode, 142, 34, 166, 3,               // 4728:        decode to t2STR_PRE using decoder 422
                                             // 4728:       }
                                             // 4728:       } // switch Inst[8]
                                             // 4728:      }
                                             // 4728:      } // switch Inst[11:10]
                                             // 4728:     }
  1, 0,                                      // 4733:     case 0x1: {
  OPC_CheckPredicate, 9,                     // 4735:      check predicate 9
  OPC_Decode, 143, 34, 185, 3,               // 4737:      decode to t2STRi12 using decoder 441
                                             // 4737:     }
                                             // 4737:     } // switch Inst[23]
                                             // 4737:    }
  1, 0,                                      // 4742:    case 0x1: {
  OPC_Scope, 79,                             // 4744:     try {
  OPC_SwitchField, 23, 1,                    // 4746:      switch Inst[23] {
  0, 65,                                     // 4749:      case 0x0: {
  OPC_SwitchField, 10, 2,                    // 4751:       switch Inst[11:10] {
  0, 11,                                     // 4754:       case 0x0: {
  OPC_CheckPredicate, 9,                     // 4756:        check predicate 9
  OPC_CheckField, 6, 4, 0,                   // 4758:        check Inst[9:6] == 0x0
  OPC_Decode, 207, 32, 170, 3,               // 4762:        decode to t2LDRs using decoder 426
                                             // 4762:       }
  2, 11,                                     // 4767:       case 0x2: {
  OPC_CheckPredicate, 9,                     // 4769:        check predicate 9
  OPC_CheckField, 8, 1, 1,                   // 4771:        check Inst[8] == 0x1
  OPC_Decode, 202, 32, 166, 3,               // 4775:        decode to t2LDR_POST using decoder 422
                                             // 4775:       }
  3, 0,                                      // 4780:       case 0x3: {
  OPC_SwitchField, 8, 1,                     // 4782:        switch Inst[8] {
  0, 20,                                     // 4785:        case 0x0: {
  OPC_Scope, 11,                             // 4787:         try {
  OPC_CheckField, 9, 1, 1,                   // 4789:          check Inst[9] == 0x1
  OPC_CheckPredicate, 9,                     // 4793:          check predicate 9
  OPC_Decode, 201, 32, 172, 3,               // 4795:          decode to t2LDRT using decoder 428
                                             // 4795:         } else try {
  OPC_CheckPredicate, 9,                     // 4800:          check predicate 9
  OPC_Decode, 205, 32, 171, 3,               // 4802:          decode to t2LDRi8 using decoder 427
                                             // 4802:         }
                                             // 4802:        }
  1, 0,                                      // 4807:        case 0x1: {
  OPC_CheckPredicate, 9,                     // 4809:         check predicate 9
  OPC_Decode, 203, 32, 166, 3,               // 4811:         decode to t2LDR_PRE using decoder 422
                                             // 4811:        }
                                             // 4811:        } // switch Inst[8]
                                             // 4811:       }
                                             // 4811:       } // switch Inst[11:10]
                                             // 4811:      }
  1, 0,                                      // 4816:      case 0x1: {
  OPC_CheckPredicate, 9,                     // 4818:       check predicate 9
  OPC_Decode, 204, 32, 173, 3,               // 4820:       decode to t2LDRi12 using decoder 429
                                             // 4820:      }
                                             // 4820:      } // switch Inst[23]
                                             // 4820:     } else try {
  OPC_CheckPredicate, 9,                     // 4825:      check predicate 9
  OPC_CheckField, 16, 4, 15,                 // 4827:      check Inst[19:16] == 0xf
  OPC_Decode, 206, 32, 174, 3,               // 4831:      decode to t2LDRpci using decoder 430
                                             // 4831:     }
                                             // 4831:    }
                                             // 4831:    } // switch Inst[20]
                                             // 4831:   }
  2, 152, 3,                                 // 4836:   case 0x2: {
  OPC_SwitchField, 7, 1,                     // 4839:    switch Inst[7] {
  0, 247, 1,                                 // 4842:    case 0x0: {
  OPC_SwitchField, 4, 3,                     // 4845:     switch Inst[6:4] {
  0, 47,                                     // 4848:     case 0x0: {
  OPC_SwitchField, 23, 1,                    // 4850:      switch Inst[23] {
  0, 11,                                     // 4853:      case 0x0: {
  OPC_CheckPredicate, 9,                     // 4855:       check predicate 9
  OPC_CheckField, 12, 4, 15,                 // 4857:       check Inst[15:12] == 0xf
  OPC_Decode, 208, 31, 230, 2,               // 4861:       decode to t2ASRrr using decoder 358
                                             // 4861:      }
  1, 0,                                      // 4866:      case 0x1: {
  OPC_SwitchField, 20, 1,                    // 4868:       switch Inst[20] {
  0, 11,                                     // 4871:       case 0x0: {
  OPC_CheckPredicate, 52,                    // 4873:        check predicate 52
  OPC_CheckField, 12, 4, 15,                 // 4875:        check Inst[15:12] == 0xf
  OPC_Decode, 221, 33, 175, 3,               // 4879:        decode to t2SSUB8 using decoder 431
                                             // 4879:       }
  1, 0,                                      // 4884:       case 0x1: {
  OPC_CheckPredicate, 52,                    // 4886:        check predicate 52
  OPC_CheckField, 12, 4, 15,                 // 4888:        check Inst[15:12] == 0xf
  OPC_Decode, 220, 33, 175, 3,               // 4892:        decode to t2SSUB16 using decoder 431
                                             // 4892:       }
                                             // 4892:       } // switch Inst[20]
                                             // 4892:      }
                                             // 4892:      } // switch Inst[23]
                                             // 4892:     }
  1, 37,                                     // 4897:     case 0x1: {
  OPC_SwitchField, 20, 1,                    // 4899:      switch Inst[20] {
  0, 15,                                     // 4902:      case 0x0: {
  OPC_CheckPredicate, 52,                    // 4904:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 4906:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 4910:       check Inst[15:12] == 0xf
  OPC_Decode, 143, 33, 175, 3,               // 4914:       decode to t2QSUB8 using decoder 431
                                             // 4914:      }
  1, 0,                                      // 4919:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 4921:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 4923:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 4927:       check Inst[15:12] == 0xf
  OPC_Decode, 142, 33, 175, 3,               // 4931:       decode to t2QSUB16 using decoder 431
                                             // 4931:      }
                                             // 4931:      } // switch Inst[20]
                                             // 4931:     }
  2, 37,                                     // 4936:     case 0x2: {
  OPC_SwitchField, 20, 1,                    // 4938:      switch Inst[20] {
  0, 15,                                     // 4941:      case 0x0: {
  OPC_CheckPredicate, 52,                    // 4943:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 4945:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 4949:       check Inst[15:12] == 0xf
  OPC_Decode, 175, 33, 175, 3,               // 4953:       decode to t2SHSUB8 using decoder 431
                                             // 4953:      }
  1, 0,                                      // 4958:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 4960:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 4962:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 4966:       check Inst[15:12] == 0xf
  OPC_Decode, 174, 33, 175, 3,               // 4970:       decode to t2SHSUB16 using decoder 431
                                             // 4970:      }
                                             // 4970:      } // switch Inst[20]
                                             // 4970:     }
  4, 37,                                     // 4975:     case 0x4: {
  OPC_SwitchField, 20, 1,                    // 4977:      switch Inst[20] {
  0, 15,                                     // 4980:      case 0x0: {
  OPC_CheckPredicate, 52,                    // 4982:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 4984:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 4988:       check Inst[15:12] == 0xf
  OPC_Decode, 199, 34, 175, 3,               // 4992:       decode to t2USUB8 using decoder 431
                                             // 4992:      }
  1, 0,                                      // 4997:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 4999:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5001:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 5005:       check Inst[15:12] == 0xf
  OPC_Decode, 198, 34, 175, 3,               // 5009:       decode to t2USUB16 using decoder 431
                                             // 5009:      }
                                             // 5009:      } // switch Inst[20]
                                             // 5009:     }
  5, 37,                                     // 5014:     case 0x5: {
  OPC_SwitchField, 20, 1,                    // 5016:      switch Inst[20] {
  0, 15,                                     // 5019:      case 0x0: {
  OPC_CheckPredicate, 52,                    // 5021:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5023:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 5027:       check Inst[15:12] == 0xf
  OPC_Decode, 192, 34, 175, 3,               // 5031:       decode to t2UQSUB8 using decoder 431
                                             // 5031:      }
  1, 0,                                      // 5036:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 5038:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5040:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 5044:       check Inst[15:12] == 0xf
  OPC_Decode, 191, 34, 175, 3,               // 5048:       decode to t2UQSUB16 using decoder 431
                                             // 5048:      }
                                             // 5048:      } // switch Inst[20]
                                             // 5048:     }
  6, 0,                                      // 5053:     case 0x6: {
  OPC_SwitchField, 20, 1,                    // 5055:      switch Inst[20] {
  0, 15,                                     // 5058:      case 0x0: {
  OPC_CheckPredicate, 52,                    // 5060:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5062:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 5066:       check Inst[15:12] == 0xf
  OPC_Decode, 183, 34, 175, 3,               // 5070:       decode to t2UHSUB8 using decoder 431
                                             // 5070:      }
  1, 0,                                      // 5075:      case 0x1: {
  OPC_CheckPredicate, 52,                    // 5077:       check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5079:       check Inst[23] == 0x1
  OPC_CheckField, 12, 4, 15,                 // 5083:       check Inst[15:12] == 0xf
  OPC_Decode, 182, 34, 175, 3,               // 5087:       decode to t2UHSUB16 using decoder 431
                                             // 5087:      }
                                             // 5087:      } // switch Inst[20]
                                             // 5087:     }
                                             // 5087:     } // switch Inst[6:4]
                                             // 5087:    }
  1, 0,                                      // 5092:    case 0x1: {
  OPC_SwitchField, 20, 1,                    // 5094:     switch Inst[20] {
  0, 73,                                     // 5097:     case 0x0: {
  OPC_SwitchField, 23, 1,                    // 5099:      switch Inst[23] {
  0, 24,                                     // 5102:      case 0x0: {
  OPC_CheckField, 12, 4, 15,                 // 5104:       check Inst[15:12] == 0xf
  OPC_Scope, 11,                             // 5108:       try {
  OPC_CheckField, 16, 4, 15,                 // 5110:        check Inst[19:16] == 0xf
  OPC_CheckPredicate, 9,                     // 5114:        check predicate 9
  OPC_Decode, 156, 34, 176, 3,               // 5116:        decode to t2SXTB using decoder 432
                                             // 5116:       } else try {
  OPC_CheckPredicate, 50,                    // 5121:        check predicate 50
  OPC_Decode, 153, 34, 177, 3,               // 5123:        decode to t2SXTAB using decoder 433
                                             // 5123:       }
                                             // 5123:      }
  1, 0,                                      // 5128:      case 0x1: {
  OPC_SwitchField, 4, 3,                     // 5130:       switch Inst[6:4] {
  0, 11,                                     // 5133:       case 0x0: {
  OPC_CheckPredicate, 67,                    // 5135:        check predicate 67
  OPC_CheckField, 12, 4, 15,                 // 5137:        check Inst[15:12] == 0xf
  OPC_Decode, 241, 31, 186, 3,               // 5141:        decode to t2CRC32B using decoder 442
                                             // 5141:       }
  1, 11,                                     // 5146:       case 0x1: {
  OPC_CheckPredicate, 67,                    // 5148:        check predicate 67
  OPC_CheckField, 12, 4, 15,                 // 5150:        check Inst[15:12] == 0xf
  OPC_Decode, 245, 31, 186, 3,               // 5154:        decode to t2CRC32H using decoder 442
                                             // 5154:       }
  2, 0,                                      // 5159:       case 0x2: {
  OPC_CheckPredicate, 67,                    // 5161:        check predicate 67
  OPC_CheckField, 12, 4, 15,                 // 5163:        check Inst[15:12] == 0xf
  OPC_Decode, 246, 31, 186, 3,               // 5167:        decode to t2CRC32W using decoder 442
                                             // 5167:       }
                                             // 5167:       } // switch Inst[6:4]
                                             // 5167:      }
                                             // 5167:      } // switch Inst[23]
                                             // 5167:     }
  1, 0,                                      // 5172:     case 0x1: {
  OPC_SwitchField, 23, 1,                    // 5174:      switch Inst[23] {
  0, 24,                                     // 5177:      case 0x0: {
  OPC_CheckField, 12, 4, 15,                 // 5179:       check Inst[15:12] == 0xf
  OPC_Scope, 11,                             // 5183:       try {
  OPC_CheckField, 16, 4, 15,                 // 5185:        check Inst[19:16] == 0xf
  OPC_CheckPredicate, 9,                     // 5189:        check predicate 9
  OPC_Decode, 203, 34, 176, 3,               // 5191:        decode to t2UXTB using decoder 432
                                             // 5191:       } else try {
  OPC_CheckPredicate, 50,                    // 5196:        check predicate 50
  OPC_Decode, 200, 34, 177, 3,               // 5198:        decode to t2UXTAB using decoder 433
                                             // 5198:       }
                                             // 5198:      }
  1, 0,                                      // 5203:      case 0x1: {
  OPC_SwitchField, 4, 3,                     // 5205:       switch Inst[6:4] {
  0, 11,                                     // 5208:       case 0x0: {
  OPC_CheckPredicate, 67,                    // 5210:        check predicate 67
  OPC_CheckField, 12, 4, 15,                 // 5212:        check Inst[15:12] == 0xf
  OPC_Decode, 242, 31, 186, 3,               // 5216:        decode to t2CRC32CB using decoder 442
                                             // 5216:       }
  1, 11,                                     // 5221:       case 0x1: {
  OPC_CheckPredicate, 67,                    // 5223:        check predicate 67
  OPC_CheckField, 12, 4, 15,                 // 5225:        check Inst[15:12] == 0xf
  OPC_Decode, 243, 31, 186, 3,               // 5229:        decode to t2CRC32CH using decoder 442
                                             // 5229:       }
  2, 0,                                      // 5234:       case 0x2: {
  OPC_CheckPredicate, 67,                    // 5236:        check predicate 67
  OPC_CheckField, 12, 4, 15,                 // 5238:        check Inst[15:12] == 0xf
  OPC_Decode, 244, 31, 186, 3,               // 5242:        decode to t2CRC32CW using decoder 442
                                             // 5242:       }
                                             // 5242:       } // switch Inst[6:4]
                                             // 5242:      }
                                             // 5242:      } // switch Inst[23]
                                             // 5242:     }
                                             // 5242:     } // switch Inst[20]
                                             // 5242:    }
                                             // 5242:    } // switch Inst[7]
                                             // 5242:   }
  3, 0,                                      // 5247:   case 0x3: {
  OPC_SwitchField, 4, 4,                     // 5249:    switch Inst[7:4] {
  0, 78,                                     // 5252:    case 0x0: {
  OPC_SwitchField, 20, 1,                    // 5254:     switch Inst[20] {
  0, 34,                                     // 5257:     case 0x0: {
  OPC_SwitchField, 23, 1,                    // 5259:      switch Inst[23] {
  0, 20,                                     // 5262:      case 0x0: {
  OPC_Scope, 11,                             // 5264:       try {
  OPC_CheckField, 12, 4, 15,                 // 5266:        check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 5270:        check predicate 52
  OPC_Decode, 211, 33, 175, 3,               // 5272:        decode to t2SMUSD using decoder 431
                                             // 5272:       } else try {
  OPC_CheckPredicate, 52,                    // 5277:        check predicate 52
  OPC_Decode, 192, 33, 180, 3,               // 5279:        decode to t2SMLSD using decoder 436
                                             // 5279:       }
                                             // 5279:      }
  1, 0,                                      // 5284:      case 0x1: {
  OPC_CheckPredicate, 9,                     // 5286:       check predicate 9
  OPC_Decode, 181, 33, 187, 3,               // 5288:       decode to t2SMLAL using decoder 443
                                             // 5288:      }
                                             // 5288:      } // switch Inst[23]
                                             // 5288:     }
  1, 0,                                      // 5293:     case 0x1: {
  OPC_CheckField, 23, 1, 0,                  // 5295:      check Inst[23] == 0x0
  OPC_Scope, 11,                             // 5299:      try {
  OPC_CheckField, 8, 4, 15,                  // 5301:       check Inst[11:8] == 0xf
  OPC_CheckPredicate, 68,                    // 5305:       check predicate 68
  OPC_Decode, 211, 31, 188, 3,               // 5307:       decode to t2AUTG using decoder 444
  OPC_Scope, 11,                             // 5312:      } else try {
  OPC_CheckField, 12, 4, 15,                 // 5314:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 5318:       check predicate 52
  OPC_Decode, 200, 33, 175, 3,               // 5320:       decode to t2SMMUL using decoder 431
                                             // 5320:      } else try {
  OPC_CheckPredicate, 52,                    // 5325:       check predicate 52
  OPC_Decode, 196, 33, 180, 3,               // 5327:       decode to t2SMMLA using decoder 436
                                             // 5327:      }
                                             // 5327:     }
                                             // 5327:     } // switch Inst[20]
                                             // 5327:    }
  1, 68,                                     // 5332:    case 0x1: {
  OPC_SwitchField, 20, 1,                    // 5334:     switch Inst[20] {
  0, 24,                                     // 5337:     case 0x0: {
  OPC_CheckField, 23, 1, 0,                  // 5339:      check Inst[23] == 0x0
  OPC_Scope, 11,                             // 5343:      try {
  OPC_CheckField, 12, 4, 15,                 // 5345:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 5349:       check predicate 52
  OPC_Decode, 212, 33, 175, 3,               // 5351:       decode to t2SMUSDX using decoder 431
                                             // 5351:      } else try {
  OPC_CheckPredicate, 52,                    // 5356:       check predicate 52
  OPC_Decode, 193, 33, 180, 3,               // 5358:       decode to t2SMLSDX using decoder 436
                                             // 5358:      }
                                             // 5358:     }
  1, 0,                                      // 5363:     case 0x1: {
  OPC_CheckField, 23, 1, 0,                  // 5365:      check Inst[23] == 0x0
  OPC_Scope, 11,                             // 5369:      try {
  OPC_CheckField, 8, 4, 15,                  // 5371:       check Inst[11:8] == 0xf
  OPC_CheckPredicate, 68,                    // 5375:       check predicate 68
  OPC_Decode, 224, 31, 189, 3,               // 5377:       decode to t2BXAUT using decoder 445
  OPC_Scope, 11,                             // 5382:      } else try {
  OPC_CheckField, 12, 4, 15,                 // 5384:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 5388:       check predicate 52
  OPC_Decode, 201, 33, 175, 3,               // 5390:       decode to t2SMMULR using decoder 431
                                             // 5390:      } else try {
  OPC_CheckPredicate, 52,                    // 5395:       check predicate 52
  OPC_Decode, 197, 33, 180, 3,               // 5397:       decode to t2SMMLAR using decoder 436
                                             // 5397:      }
                                             // 5397:     }
                                             // 5397:     } // switch Inst[20]
                                             // 5397:    }
  8, 15,                                     // 5402:    case 0x8: {
  OPC_CheckPredicate, 52,                    // 5404:     check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5406:     check Inst[23] == 0x1
  OPC_CheckField, 20, 1, 0,                  // 5410:     check Inst[20] == 0x0
  OPC_Decode, 182, 33, 187, 3,               // 5414:     decode to t2SMLALBB using decoder 443
                                             // 5414:    }
  9, 15,                                     // 5419:    case 0x9: {
  OPC_CheckPredicate, 52,                    // 5421:     check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5423:     check Inst[23] == 0x1
  OPC_CheckField, 20, 1, 0,                  // 5427:     check Inst[20] == 0x0
  OPC_Decode, 183, 33, 187, 3,               // 5431:     decode to t2SMLALBT using decoder 443
                                             // 5431:    }
  10, 15,                                    // 5436:    case 0xa: {
  OPC_CheckPredicate, 52,                    // 5438:     check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5440:     check Inst[23] == 0x1
  OPC_CheckField, 20, 1, 0,                  // 5444:     check Inst[20] == 0x0
  OPC_Decode, 186, 33, 187, 3,               // 5448:     decode to t2SMLALTB using decoder 443
                                             // 5448:    }
  11, 15,                                    // 5453:    case 0xb: {
  OPC_CheckPredicate, 52,                    // 5455:     check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5457:     check Inst[23] == 0x1
  OPC_CheckField, 20, 1, 0,                  // 5461:     check Inst[20] == 0x0
  OPC_Decode, 187, 33, 187, 3,               // 5465:     decode to t2SMLALTT using decoder 443
                                             // 5465:    }
  12, 29,                                    // 5470:    case 0xc: {
  OPC_SwitchField, 20, 1,                    // 5472:     switch Inst[20] {
  0, 11,                                     // 5475:     case 0x0: {
  OPC_CheckPredicate, 52,                    // 5477:      check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5479:      check Inst[23] == 0x1
  OPC_Decode, 184, 33, 187, 3,               // 5483:      decode to t2SMLALD using decoder 443
                                             // 5483:     }
  1, 0,                                      // 5488:     case 0x1: {
  OPC_CheckPredicate, 52,                    // 5490:      check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5492:      check Inst[23] == 0x1
  OPC_Decode, 194, 33, 187, 3,               // 5496:      decode to t2SMLSLD using decoder 443
                                             // 5496:     }
                                             // 5496:     } // switch Inst[20]
                                             // 5496:    }
  13, 0,                                     // 5501:    case 0xd: {
  OPC_SwitchField, 20, 1,                    // 5503:     switch Inst[20] {
  0, 11,                                     // 5506:     case 0x0: {
  OPC_CheckPredicate, 52,                    // 5508:      check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5510:      check Inst[23] == 0x1
  OPC_Decode, 185, 33, 187, 3,               // 5514:      decode to t2SMLALDX using decoder 443
                                             // 5514:     }
  1, 0,                                      // 5519:     case 0x1: {
  OPC_CheckPredicate, 52,                    // 5521:      check predicate 52
  OPC_CheckField, 23, 1, 1,                  // 5523:      check Inst[23] == 0x1
  OPC_Decode, 195, 33, 187, 3,               // 5527:      decode to t2SMLSLDX using decoder 443
                                             // 5527:     }
                                             // 5527:     } // switch Inst[20]
                                             // 5527:    }
                                             // 5527:    } // switch Inst[7:4]
                                             // 5527:   }
                                             // 5527:   } // switch Inst[26:24]
                                             // 5527:  }
  3, 0,                                      // 5532:  case 0x3: {
  OPC_SwitchField, 4, 4,                     // 5534:   switch Inst[7:4] {
  0, 95,                                     // 5537:   case 0x0: {
  OPC_SwitchField, 23, 4,                    // 5539:    switch Inst[26:23] {
  4, 11,                                     // 5542:    case 0x4: {
  OPC_CheckPredicate, 9,                     // 5544:     check predicate 9
  OPC_CheckField, 12, 4, 15,                 // 5546:     check Inst[15:12] == 0xf
  OPC_Decode, 153, 33, 230, 2,               // 5550:     decode to t2RORrr using decoder 358
                                             // 5550:    }
  5, 15,                                     // 5555:    case 0x5: {
  OPC_CheckPredicate, 52,                    // 5557:     check predicate 52
  OPC_CheckField, 20, 1, 0,                  // 5559:     check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 5563:     check Inst[15:12] == 0xf
  OPC_Decode, 219, 33, 175, 3,               // 5567:     decode to t2SSAX using decoder 431
                                             // 5567:    }
  6, 47,                                     // 5572:    case 0x6: {
  OPC_SwitchField, 20, 1,                    // 5574:     switch Inst[20] {
  0, 20,                                     // 5577:     case 0x0: {
  OPC_Scope, 11,                             // 5579:      try {
  OPC_CheckField, 12, 4, 15,                 // 5581:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 68,                    // 5585:       check predicate 68
  OPC_Decode, 248, 32, 190, 3,               // 5587:       decode to t2PACG using decoder 446
                                             // 5587:      } else try {
  OPC_CheckPredicate, 52,                    // 5592:       check predicate 52
  OPC_Decode, 198, 33, 180, 3,               // 5594:       decode to t2SMMLS using decoder 436
                                             // 5594:      }
                                             // 5594:     }
  1, 0,                                      // 5599:     case 0x1: {
  OPC_Scope, 11,                             // 5601:      try {
  OPC_CheckField, 12, 4, 15,                 // 5603:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 52,                    // 5607:       check predicate 52
  OPC_Decode, 193, 34, 175, 3,               // 5609:       decode to t2USAD8 using decoder 431
                                             // 5609:      } else try {
  OPC_CheckPredicate, 52,                    // 5614:       check predicate 52
  OPC_Decode, 194, 34, 180, 3,               // 5616:       decode to t2USADA8 using decoder 436
                                             // 5616:      }
                                             // 5616:     }
                                             // 5616:     } // switch Inst[20]
                                             // 5616:    }
  7, 0,                                      // 5621:    case 0x7: {
  OPC_CheckPredicate, 9,                     // 5623:     check predicate 9
  OPC_CheckField, 20, 1, 0,                  // 5625:     check Inst[20] == 0x0
  OPC_Decode, 185, 34, 187, 3,               // 5629:     decode to t2UMLAL using decoder 443
                                             // 5629:    }
                                             // 5629:    } // switch Inst[26:23]
                                             // 5629:   }
  1, 33,                                     // 5634:   case 0x1: {
  OPC_SwitchField, 23, 4,                    // 5636:    switch Inst[26:23] {
  5, 15,                                     // 5639:    case 0x5: {
  OPC_CheckPredicate, 52,                    // 5641:     check predicate 52
  OPC_CheckField, 20, 1, 0,                  // 5643:     check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 5647:     check Inst[15:12] == 0xf
  OPC_Decode, 140, 33, 175, 3,               // 5651:     decode to t2QSAX using decoder 431
                                             // 5651:    }
  6, 0,                                      // 5656:    case 0x6: {
  OPC_CheckPredicate, 52,                    // 5658:     check predicate 52
  OPC_CheckField, 20, 1, 0,                  // 5660:     check Inst[20] == 0x0
  OPC_Decode, 199, 33, 180, 3,               // 5664:     decode to t2SMMLSR using decoder 436
                                             // 5664:    }
                                             // 5664:    } // switch Inst[26:23]
                                             // 5664:   }
  2, 19,                                     // 5669:   case 0x2: {
  OPC_CheckPredicate, 52,                    // 5671:    check predicate 52
  OPC_CheckField, 23, 4, 5,                  // 5673:    check Inst[26:23] == 0x5
  OPC_CheckField, 20, 1, 0,                  // 5677:    check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 5681:    check Inst[15:12] == 0xf
  OPC_Decode, 173, 33, 175, 3,               // 5685:    decode to t2SHSAX using decoder 431
                                             // 5685:   }
  4, 19,                                     // 5690:   case 0x4: {
  OPC_CheckPredicate, 52,                    // 5692:    check predicate 52
  OPC_CheckField, 23, 4, 5,                  // 5694:    check Inst[26:23] == 0x5
  OPC_CheckField, 20, 1, 0,                  // 5698:    check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 5702:    check Inst[15:12] == 0xf
  OPC_Decode, 197, 34, 175, 3,               // 5706:    decode to t2USAX using decoder 431
                                             // 5706:   }
  5, 19,                                     // 5711:   case 0x5: {
  OPC_CheckPredicate, 52,                    // 5713:    check predicate 52
  OPC_CheckField, 23, 4, 5,                  // 5715:    check Inst[26:23] == 0x5
  OPC_CheckField, 20, 1, 0,                  // 5719:    check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 5723:    check Inst[15:12] == 0xf
  OPC_Decode, 190, 34, 175, 3,               // 5727:    decode to t2UQSAX using decoder 431
                                             // 5727:   }
  6, 0,                                      // 5732:   case 0x6: {
  OPC_SwitchField, 23, 4,                    // 5734:    switch Inst[26:23] {
  5, 15,                                     // 5737:    case 0x5: {
  OPC_CheckPredicate, 52,                    // 5739:     check predicate 52
  OPC_CheckField, 20, 1, 0,                  // 5741:     check Inst[20] == 0x0
  OPC_CheckField, 12, 4, 15,                 // 5745:     check Inst[15:12] == 0xf
  OPC_Decode, 181, 34, 175, 3,               // 5749:     decode to t2UHSAX using decoder 431
                                             // 5749:    }
  7, 0,                                      // 5754:    case 0x7: {
  OPC_CheckPredicate, 52,                    // 5756:     check predicate 52
  OPC_CheckField, 20, 1, 0,                  // 5758:     check Inst[20] == 0x0
  OPC_Decode, 184, 34, 187, 3,               // 5762:     decode to t2UMAAL using decoder 443
                                             // 5762:    }
                                             // 5762:    } // switch Inst[26:23]
                                             // 5762:   }
                                             // 5762:   } // switch Inst[7:4]
                                             // 5762:  }
                                             // 5762:  } // switch Inst[22:21]
                                             // 5762: }
                                             // 5762: } // switch Inst[31:27]
};
static const uint8_t DecoderTableThumb2CDE32[565] = {
  OPC_SwitchField, 25, 7,                    //   0: switch Inst[31:25] {
  118, 175, 1,                               //   3: case 0x76: {
  OPC_SwitchField, 6, 1,                     //   6:  switch Inst[6] {
  0, 91,                                     //   9:  case 0x0: {
  OPC_SwitchField, 23, 2,                    //  11:   switch Inst[24:23] {
  0, 29,                                     //  14:   case 0x0: {
  OPC_SwitchField, 20, 2,                    //  16:    switch Inst[21:20] {
  2, 11,                                     //  19:    case 0x2: {
  OPC_CheckPredicate, 69,                    //  21:     check predicate 69
  OPC_CheckField, 11, 1, 0,                  //  23:     check Inst[11] == 0x0
  OPC_Decode, 218, 6, 191, 3,                //  27:     decode to CDE_VCX1_fpsp using decoder 447
                                             //  27:    }
  3, 0,                                      //  32:    case 0x3: {
  OPC_CheckPredicate, 69,                    //  34:     check predicate 69
  OPC_CheckField, 11, 1, 0,                  //  36:     check Inst[11] == 0x0
  OPC_Decode, 224, 6, 192, 3,                //  40:     decode to CDE_VCX2_fpsp using decoder 448
                                             //  40:    }
                                             //  40:    } // switch Inst[21:20]
                                             //  40:   }
  1, 11,                                     //  45:   case 0x1: {
  OPC_CheckPredicate, 69,                    //  47:    check predicate 69
  OPC_CheckField, 11, 1, 0,                  //  49:    check Inst[11] == 0x0
  OPC_Decode, 230, 6, 193, 3,                //  53:    decode to CDE_VCX3_fpsp using decoder 449
                                             //  53:   }
  2, 29,                                     //  58:   case 0x2: {
  OPC_SwitchField, 20, 2,                    //  60:    switch Inst[21:20] {
  2, 11,                                     //  63:    case 0x2: {
  OPC_CheckPredicate, 69,                    //  65:     check predicate 69
  OPC_CheckField, 11, 1, 0,                  //  67:     check Inst[11] == 0x0
  OPC_Decode, 217, 6, 194, 3,                //  71:     decode to CDE_VCX1_fpdp using decoder 450
                                             //  71:    }
  3, 0,                                      //  76:    case 0x3: {
  OPC_CheckPredicate, 69,                    //  78:     check predicate 69
  OPC_CheckField, 11, 1, 0,                  //  80:     check Inst[11] == 0x0
  OPC_Decode, 223, 6, 195, 3,                //  84:     decode to CDE_VCX2_fpdp using decoder 451
                                             //  84:    }
                                             //  84:    } // switch Inst[21:20]
                                             //  84:   }
  3, 0,                                      //  89:   case 0x3: {
  OPC_CheckPredicate, 69,                    //  91:    check predicate 69
  OPC_CheckField, 11, 1, 0,                  //  93:    check Inst[11] == 0x0
  OPC_Decode, 229, 6, 196, 3,                //  97:    decode to CDE_VCX3_fpdp using decoder 452
                                             //  97:   }
                                             //  97:   } // switch Inst[24:23]
                                             //  97:  }
  1, 0,                                      // 102:  case 0x1: {
  OPC_SwitchField, 23, 1,                    // 104:   switch Inst[23] {
  0, 45,                                     // 107:   case 0x0: {
  OPC_SwitchField, 20, 2,                    // 109:    switch Inst[21:20] {
  2, 17,                                     // 112:    case 0x2: {
  OPC_CheckPredicate, 70,                    // 114:     check predicate 70
  OPC_CheckField, 11, 2, 0,                  // 116:     check Inst[12:11] == 0x0
  OPC_SoftFail, 128, 128, 128, 2, 0,         // 120:     softfail pos=0x00400000 neg=0x00000000
  OPC_Decode, 219, 6, 197, 3,                // 126:     decode to CDE_VCX1_vec using decoder 453
                                             // 126:    }
  3, 0,                                      // 131:    case 0x3: {
  OPC_CheckPredicate, 70,                    // 133:     check predicate 70
  OPC_CheckField, 11, 2, 0,                  // 135:     check Inst[12:11] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 139:     check Inst[0] == 0x0
  OPC_SoftFail, 160, 128, 128, 2, 0,         // 143:     softfail pos=0x00400020 neg=0x00000000
  OPC_Decode, 225, 6, 198, 3,                // 149:     decode to CDE_VCX2_vec using decoder 454
                                             // 149:    }
                                             // 149:    } // switch Inst[21:20]
                                             // 149:   }
  1, 0,                                      // 154:   case 0x1: {
  OPC_CheckPredicate, 70,                    // 156:    check predicate 70
  OPC_CheckField, 16, 1, 0,                  // 158:    check Inst[16] == 0x0
  OPC_CheckField, 11, 2, 0,                  // 162:    check Inst[12:11] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 166:    check Inst[0] == 0x0
  OPC_SoftFail, 160, 129, 128, 2, 0,         // 170:    softfail pos=0x004000a0 neg=0x00000000
  OPC_Decode, 231, 6, 199, 3,                // 176:    decode to CDE_VCX3_vec using decoder 455
                                             // 176:   }
                                             // 176:   } // switch Inst[23]
                                             // 176:  }
                                             // 176:  } // switch Inst[6]
                                             // 176: }
  119, 101,                                  // 181: case 0x77: {
  OPC_SwitchField, 6, 1,                     // 183:  switch Inst[6] {
  0, 47,                                     // 186:  case 0x0: {
  OPC_SwitchField, 23, 2,                    // 188:   switch Inst[24:23] {
  0, 29,                                     // 191:   case 0x0: {
  OPC_SwitchField, 22, 1,                    // 193:    switch Inst[22] {
  0, 11,                                     // 196:    case 0x0: {
  OPC_CheckPredicate, 71,                    // 198:     check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 200:     check Inst[11] == 0x0
  OPC_Decode, 202, 6, 200, 3,                // 204:     decode to CDE_CX1 using decoder 456
                                             // 204:    }
  1, 0,                                      // 209:    case 0x1: {
  OPC_CheckPredicate, 71,                    // 211:     check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 213:     check Inst[11] == 0x0
  OPC_Decode, 206, 6, 201, 3,                // 217:     decode to CDE_CX2 using decoder 457
                                             // 217:    }
                                             // 217:    } // switch Inst[22]
                                             // 217:   }
  1, 0,                                      // 222:   case 0x1: {
  OPC_CheckPredicate, 71,                    // 224:    check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 226:    check Inst[11] == 0x0
  OPC_Decode, 210, 6, 202, 3,                // 230:    decode to CDE_CX3 using decoder 458
                                             // 230:   }
                                             // 230:   } // switch Inst[24:23]
                                             // 230:  }
  1, 0,                                      // 235:  case 0x1: {
  OPC_SwitchField, 23, 2,                    // 237:   switch Inst[24:23] {
  0, 29,                                     // 240:   case 0x0: {
  OPC_SwitchField, 22, 1,                    // 242:    switch Inst[22] {
  0, 11,                                     // 245:    case 0x0: {
  OPC_CheckPredicate, 71,                    // 247:     check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 249:     check Inst[11] == 0x0
  OPC_Decode, 204, 6, 203, 3,                // 253:     decode to CDE_CX1D using decoder 459
                                             // 253:    }
  1, 0,                                      // 258:    case 0x1: {
  OPC_CheckPredicate, 71,                    // 260:     check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 262:     check Inst[11] == 0x0
  OPC_Decode, 208, 6, 204, 3,                // 266:     decode to CDE_CX2D using decoder 460
                                             // 266:    }
                                             // 266:    } // switch Inst[22]
                                             // 266:   }
  1, 0,                                      // 271:   case 0x1: {
  OPC_CheckPredicate, 71,                    // 273:    check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 275:    check Inst[11] == 0x0
  OPC_Decode, 212, 6, 205, 3,                // 279:    decode to CDE_CX3D using decoder 461
                                             // 279:   }
                                             // 279:   } // switch Inst[24:23]
                                             // 279:  }
                                             // 279:  } // switch Inst[6]
                                             // 279: }
  126, 175, 1,                               // 284: case 0x7e: {
  OPC_SwitchField, 6, 1,                     // 287:  switch Inst[6] {
  0, 91,                                     // 290:  case 0x0: {
  OPC_SwitchField, 23, 2,                    // 292:   switch Inst[24:23] {
  0, 29,                                     // 295:   case 0x0: {
  OPC_SwitchField, 20, 2,                    // 297:    switch Inst[21:20] {
  2, 11,                                     // 300:    case 0x2: {
  OPC_CheckPredicate, 69,                    // 302:     check predicate 69
  OPC_CheckField, 11, 1, 0,                  // 304:     check Inst[11] == 0x0
  OPC_Decode, 215, 6, 206, 3,                // 308:     decode to CDE_VCX1A_fpsp using decoder 462
                                             // 308:    }
  3, 0,                                      // 313:    case 0x3: {
  OPC_CheckPredicate, 69,                    // 315:     check predicate 69
  OPC_CheckField, 11, 1, 0,                  // 317:     check Inst[11] == 0x0
  OPC_Decode, 221, 6, 207, 3,                // 321:     decode to CDE_VCX2A_fpsp using decoder 463
                                             // 321:    }
                                             // 321:    } // switch Inst[21:20]
                                             // 321:   }
  1, 11,                                     // 326:   case 0x1: {
  OPC_CheckPredicate, 69,                    // 328:    check predicate 69
  OPC_CheckField, 11, 1, 0,                  // 330:    check Inst[11] == 0x0
  OPC_Decode, 227, 6, 208, 3,                // 334:    decode to CDE_VCX3A_fpsp using decoder 464
                                             // 334:   }
  2, 29,                                     // 339:   case 0x2: {
  OPC_SwitchField, 20, 2,                    // 341:    switch Inst[21:20] {
  2, 11,                                     // 344:    case 0x2: {
  OPC_CheckPredicate, 69,                    // 346:     check predicate 69
  OPC_CheckField, 11, 1, 0,                  // 348:     check Inst[11] == 0x0
  OPC_Decode, 214, 6, 209, 3,                // 352:     decode to CDE_VCX1A_fpdp using decoder 465
                                             // 352:    }
  3, 0,                                      // 357:    case 0x3: {
  OPC_CheckPredicate, 69,                    // 359:     check predicate 69
  OPC_CheckField, 11, 1, 0,                  // 361:     check Inst[11] == 0x0
  OPC_Decode, 220, 6, 210, 3,                // 365:     decode to CDE_VCX2A_fpdp using decoder 466
                                             // 365:    }
                                             // 365:    } // switch Inst[21:20]
                                             // 365:   }
  3, 0,                                      // 370:   case 0x3: {
  OPC_CheckPredicate, 69,                    // 372:    check predicate 69
  OPC_CheckField, 11, 1, 0,                  // 374:    check Inst[11] == 0x0
  OPC_Decode, 226, 6, 211, 3,                // 378:    decode to CDE_VCX3A_fpdp using decoder 467
                                             // 378:   }
                                             // 378:   } // switch Inst[24:23]
                                             // 378:  }
  1, 0,                                      // 383:  case 0x1: {
  OPC_SwitchField, 23, 1,                    // 385:   switch Inst[23] {
  0, 45,                                     // 388:   case 0x0: {
  OPC_SwitchField, 20, 2,                    // 390:    switch Inst[21:20] {
  2, 17,                                     // 393:    case 0x2: {
  OPC_CheckPredicate, 70,                    // 395:     check predicate 70
  OPC_CheckField, 11, 2, 0,                  // 397:     check Inst[12:11] == 0x0
  OPC_SoftFail, 128, 128, 128, 2, 0,         // 401:     softfail pos=0x00400000 neg=0x00000000
  OPC_Decode, 216, 6, 212, 3,                // 407:     decode to CDE_VCX1A_vec using decoder 468
                                             // 407:    }
  3, 0,                                      // 412:    case 0x3: {
  OPC_CheckPredicate, 70,                    // 414:     check predicate 70
  OPC_CheckField, 11, 2, 0,                  // 416:     check Inst[12:11] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 420:     check Inst[0] == 0x0
  OPC_SoftFail, 160, 128, 128, 2, 0,         // 424:     softfail pos=0x00400020 neg=0x00000000
  OPC_Decode, 222, 6, 213, 3,                // 430:     decode to CDE_VCX2A_vec using decoder 469
                                             // 430:    }
                                             // 430:    } // switch Inst[21:20]
                                             // 430:   }
  1, 0,                                      // 435:   case 0x1: {
  OPC_CheckPredicate, 70,                    // 437:    check predicate 70
  OPC_CheckField, 16, 1, 0,                  // 439:    check Inst[16] == 0x0
  OPC_CheckField, 11, 2, 0,                  // 443:    check Inst[12:11] == 0x0
  OPC_CheckField, 0, 1, 0,                   // 447:    check Inst[0] == 0x0
  OPC_SoftFail, 160, 129, 128, 2, 0,         // 451:    softfail pos=0x004000a0 neg=0x00000000
  OPC_Decode, 228, 6, 214, 3,                // 457:    decode to CDE_VCX3A_vec using decoder 470
                                             // 457:   }
                                             // 457:   } // switch Inst[23]
                                             // 457:  }
                                             // 457:  } // switch Inst[6]
                                             // 457: }
  127, 0,                                    // 462: case 0x7f: {
  OPC_SwitchField, 6, 1,                     // 464:  switch Inst[6] {
  0, 47,                                     // 467:  case 0x0: {
  OPC_SwitchField, 23, 2,                    // 469:   switch Inst[24:23] {
  0, 29,                                     // 472:   case 0x0: {
  OPC_SwitchField, 22, 1,                    // 474:    switch Inst[22] {
  0, 11,                                     // 477:    case 0x0: {
  OPC_CheckPredicate, 71,                    // 479:     check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 481:     check Inst[11] == 0x0
  OPC_Decode, 203, 6, 215, 3,                // 485:     decode to CDE_CX1A using decoder 471
                                             // 485:    }
  1, 0,                                      // 490:    case 0x1: {
  OPC_CheckPredicate, 71,                    // 492:     check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 494:     check Inst[11] == 0x0
  OPC_Decode, 207, 6, 216, 3,                // 498:     decode to CDE_CX2A using decoder 472
                                             // 498:    }
                                             // 498:    } // switch Inst[22]
                                             // 498:   }
  1, 0,                                      // 503:   case 0x1: {
  OPC_CheckPredicate, 71,                    // 505:    check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 507:    check Inst[11] == 0x0
  OPC_Decode, 211, 6, 217, 3,                // 511:    decode to CDE_CX3A using decoder 473
                                             // 511:   }
                                             // 511:   } // switch Inst[24:23]
                                             // 511:  }
  1, 0,                                      // 516:  case 0x1: {
  OPC_SwitchField, 23, 2,                    // 518:   switch Inst[24:23] {
  0, 29,                                     // 521:   case 0x0: {
  OPC_SwitchField, 22, 1,                    // 523:    switch Inst[22] {
  0, 11,                                     // 526:    case 0x0: {
  OPC_CheckPredicate, 71,                    // 528:     check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 530:     check Inst[11] == 0x0
  OPC_Decode, 205, 6, 218, 3,                // 534:     decode to CDE_CX1DA using decoder 474
                                             // 534:    }
  1, 0,                                      // 539:    case 0x1: {
  OPC_CheckPredicate, 71,                    // 541:     check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 543:     check Inst[11] == 0x0
  OPC_Decode, 209, 6, 219, 3,                // 547:     decode to CDE_CX2DA using decoder 475
                                             // 547:    }
                                             // 547:    } // switch Inst[22]
                                             // 547:   }
  1, 0,                                      // 552:   case 0x1: {
  OPC_CheckPredicate, 71,                    // 554:    check predicate 71
  OPC_CheckField, 11, 1, 0,                  // 556:    check Inst[11] == 0x0
  OPC_Decode, 213, 6, 220, 3,                // 560:    decode to CDE_CX3DA using decoder 476
                                             // 560:   }
                                             // 560:   } // switch Inst[24:23]
                                             // 560:  }
                                             // 560:  } // switch Inst[6]
                                             // 560: }
                                             // 560: } // switch Inst[31:25]
};
static const uint8_t DecoderTableThumb2CoProc32[463] = {
  OPC_SwitchField, 24, 8,                    //   0: switch Inst[31:24] {
  236, 1, 111,                               //   3: case 0xec: {
  OPC_SwitchField, 20, 3,                    //   6:  switch Inst[22:20] {
  0, 11,                                     //   9:  case 0x0: {
  OPC_CheckPredicate, 9,                     //  11:   check predicate 9
  OPC_CheckField, 23, 1, 1,                  //  13:   check Inst[23] == 0x1
  OPC_Decode, 235, 33, 128, 1,               //  17:   decode to t2STC_OPTION using decoder 128
                                             //  17:  }
  1, 11,                                     //  22:  case 0x1: {
  OPC_CheckPredicate, 9,                     //  24:   check predicate 9
  OPC_CheckField, 23, 1, 1,                  //  26:   check Inst[23] == 0x1
  OPC_Decode, 159, 32, 128, 1,               //  30:   decode to t2LDC_OPTION using decoder 128
                                             //  30:  }
  2, 7,                                      //  35:  case 0x2: {
  OPC_CheckPredicate, 9,                     //  37:   check predicate 9
  OPC_Decode, 236, 33, 128, 1,               //  39:   decode to t2STC_POST using decoder 128
                                             //  39:  }
  3, 7,                                      //  44:  case 0x3: {
  OPC_CheckPredicate, 9,                     //  46:   check predicate 9
  OPC_Decode, 160, 32, 128, 1,               //  48:   decode to t2LDC_POST using decoder 128
                                             //  48:  }
  4, 21,                                     //  53:  case 0x4: {
  OPC_SwitchField, 23, 1,                    //  55:   switch Inst[23] {
  0, 7,                                      //  58:   case 0x0: {
  OPC_CheckPredicate, 9,                     //  60:    check predicate 9
  OPC_Decode, 217, 32, 221, 3,               //  62:    decode to t2MCRR using decoder 477
                                             //  62:   }
  1, 0,                                      //  67:   case 0x1: {
  OPC_CheckPredicate, 9,                     //  69:    check predicate 9
  OPC_Decode, 231, 33, 128, 1,               //  71:    decode to t2STCL_OPTION using decoder 128
                                             //  71:   }
                                             //  71:   } // switch Inst[23]
                                             //  71:  }
  5, 21,                                     //  76:  case 0x5: {
  OPC_SwitchField, 23, 1,                    //  78:   switch Inst[23] {
  0, 7,                                      //  81:   case 0x0: {
  OPC_CheckPredicate, 9,                     //  83:    check predicate 9
  OPC_Decode, 227, 32, 222, 3,               //  85:    decode to t2MRRC using decoder 478
                                             //  85:   }
  1, 0,                                      //  90:   case 0x1: {
  OPC_CheckPredicate, 9,                     //  92:    check predicate 9
  OPC_Decode, 155, 32, 128, 1,               //  94:    decode to t2LDCL_OPTION using decoder 128
                                             //  94:   }
                                             //  94:   } // switch Inst[23]
                                             //  94:  }
  6, 7,                                      //  99:  case 0x6: {
  OPC_CheckPredicate, 9,                     // 101:   check predicate 9
  OPC_Decode, 232, 33, 128, 1,               // 103:   decode to t2STCL_POST using decoder 128
                                             // 103:  }
  7, 0,                                      // 108:  case 0x7: {
  OPC_CheckPredicate, 9,                     // 110:   check predicate 9
  OPC_Decode, 156, 32, 128, 1,               // 112:   decode to t2LDCL_POST using decoder 128
                                             // 112:  }
                                             // 112:  } // switch Inst[22:20]
                                             // 112: }
  237, 1, 75,                                // 117: case 0xed: {
  OPC_SwitchField, 20, 3,                    // 120:  switch Inst[22:20] {
  0, 7,                                      // 123:  case 0x0: {
  OPC_CheckPredicate, 9,                     // 125:   check predicate 9
  OPC_Decode, 234, 33, 128, 1,               // 127:   decode to t2STC_OFFSET using decoder 128
                                             // 127:  }
  1, 7,                                      // 132:  case 0x1: {
  OPC_CheckPredicate, 9,                     // 134:   check predicate 9
  OPC_Decode, 158, 32, 128, 1,               // 136:   decode to t2LDC_OFFSET using decoder 128
                                             // 136:  }
  2, 7,                                      // 141:  case 0x2: {
  OPC_CheckPredicate, 9,                     // 143:   check predicate 9
  OPC_Decode, 237, 33, 128, 1,               // 145:   decode to t2STC_PRE using decoder 128
                                             // 145:  }
  3, 7,                                      // 150:  case 0x3: {
  OPC_CheckPredicate, 9,                     // 152:   check predicate 9
  OPC_Decode, 161, 32, 128, 1,               // 154:   decode to t2LDC_PRE using decoder 128
                                             // 154:  }
  4, 7,                                      // 159:  case 0x4: {
  OPC_CheckPredicate, 9,                     // 161:   check predicate 9
  OPC_Decode, 230, 33, 128, 1,               // 163:   decode to t2STCL_OFFSET using decoder 128
                                             // 163:  }
  5, 7,                                      // 168:  case 0x5: {
  OPC_CheckPredicate, 9,                     // 170:   check predicate 9
  OPC_Decode, 154, 32, 128, 1,               // 172:   decode to t2LDCL_OFFSET using decoder 128
                                             // 172:  }
  6, 7,                                      // 177:  case 0x6: {
  OPC_CheckPredicate, 9,                     // 179:   check predicate 9
  OPC_Decode, 233, 33, 128, 1,               // 181:   decode to t2STCL_PRE using decoder 128
                                             // 181:  }
  7, 0,                                      // 186:  case 0x7: {
  OPC_CheckPredicate, 9,                     // 188:   check predicate 9
  OPC_Decode, 157, 32, 128, 1,               // 190:   decode to t2LDCL_PRE using decoder 128
                                             // 190:  }
                                             // 190:  } // switch Inst[22:20]
                                             // 190: }
  238, 1, 35,                                // 195: case 0xee: {
  OPC_SwitchField, 4, 1,                     // 198:  switch Inst[4] {
  0, 7,                                      // 201:  case 0x0: {
  OPC_CheckPredicate, 72,                    // 203:   check predicate 72
  OPC_Decode, 227, 31, 223, 3,               // 205:   decode to t2CDP using decoder 479
                                             // 205:  }
  1, 0,                                      // 210:  case 0x1: {
  OPC_SwitchField, 20, 1,                    // 212:   switch Inst[20] {
  0, 7,                                      // 215:   case 0x0: {
  OPC_CheckPredicate, 9,                     // 217:    check predicate 9
  OPC_Decode, 215, 32, 224, 3,               // 219:    decode to t2MCR using decoder 480
                                             // 219:   }
  1, 0,                                      // 224:   case 0x1: {
  OPC_CheckPredicate, 9,                     // 226:    check predicate 9
  OPC_Decode, 225, 32, 225, 3,               // 228:    decode to t2MRC using decoder 481
                                             // 228:   }
                                             // 228:   } // switch Inst[20]
                                             // 228:  }
                                             // 228:  } // switch Inst[4]
                                             // 228: }
  252, 1, 111,                               // 233: case 0xfc: {
  OPC_SwitchField, 20, 3,                    // 236:  switch Inst[22:20] {
  0, 11,                                     // 239:  case 0x0: {
  OPC_CheckPredicate, 73,                    // 241:   check predicate 73
  OPC_CheckField, 23, 1, 1,                  // 243:   check Inst[23] == 0x1
  OPC_Decode, 227, 33, 128, 1,               // 247:   decode to t2STC2_OPTION using decoder 128
                                             // 247:  }
  1, 11,                                     // 252:  case 0x1: {
  OPC_CheckPredicate, 73,                    // 254:   check predicate 73
  OPC_CheckField, 23, 1, 1,                  // 256:   check Inst[23] == 0x1
  OPC_Decode, 151, 32, 128, 1,               // 260:   decode to t2LDC2_OPTION using decoder 128
                                             // 260:  }
  2, 7,                                      // 265:  case 0x2: {
  OPC_CheckPredicate, 73,                    // 267:   check predicate 73
  OPC_Decode, 228, 33, 128, 1,               // 269:   decode to t2STC2_POST using decoder 128
                                             // 269:  }
  3, 7,                                      // 274:  case 0x3: {
  OPC_CheckPredicate, 73,                    // 276:   check predicate 73
  OPC_Decode, 152, 32, 128, 1,               // 278:   decode to t2LDC2_POST using decoder 128
                                             // 278:  }
  4, 21,                                     // 283:  case 0x4: {
  OPC_SwitchField, 23, 1,                    // 285:   switch Inst[23] {
  0, 7,                                      // 288:   case 0x0: {
  OPC_CheckPredicate, 72,                    // 290:    check predicate 72
  OPC_Decode, 218, 32, 221, 3,               // 292:    decode to t2MCRR2 using decoder 477
                                             // 292:   }
  1, 0,                                      // 297:   case 0x1: {
  OPC_CheckPredicate, 73,                    // 299:    check predicate 73
  OPC_Decode, 223, 33, 128, 1,               // 301:    decode to t2STC2L_OPTION using decoder 128
                                             // 301:   }
                                             // 301:   } // switch Inst[23]
                                             // 301:  }
  5, 21,                                     // 306:  case 0x5: {
  OPC_SwitchField, 23, 1,                    // 308:   switch Inst[23] {
  0, 7,                                      // 311:   case 0x0: {
  OPC_CheckPredicate, 72,                    // 313:    check predicate 72
  OPC_Decode, 228, 32, 222, 3,               // 315:    decode to t2MRRC2 using decoder 478
                                             // 315:   }
  1, 0,                                      // 320:   case 0x1: {
  OPC_CheckPredicate, 73,                    // 322:    check predicate 73
  OPC_Decode, 147, 32, 128, 1,               // 324:    decode to t2LDC2L_OPTION using decoder 128
                                             // 324:   }
                                             // 324:   } // switch Inst[23]
                                             // 324:  }
  6, 7,                                      // 329:  case 0x6: {
  OPC_CheckPredicate, 73,                    // 331:   check predicate 73
  OPC_Decode, 224, 33, 128, 1,               // 333:   decode to t2STC2L_POST using decoder 128
                                             // 333:  }
  7, 0,                                      // 338:  case 0x7: {
  OPC_CheckPredicate, 73,                    // 340:   check predicate 73
  OPC_Decode, 148, 32, 128, 1,               // 342:   decode to t2LDC2L_POST using decoder 128
                                             // 342:  }
                                             // 342:  } // switch Inst[22:20]
                                             // 342: }
  253, 1, 75,                                // 347: case 0xfd: {
  OPC_SwitchField, 20, 3,                    // 350:  switch Inst[22:20] {
  0, 7,                                      // 353:  case 0x0: {
  OPC_CheckPredicate, 73,                    // 355:   check predicate 73
  OPC_Decode, 226, 33, 128, 1,               // 357:   decode to t2STC2_OFFSET using decoder 128
                                             // 357:  }
  1, 7,                                      // 362:  case 0x1: {
  OPC_CheckPredicate, 73,                    // 364:   check predicate 73
  OPC_Decode, 150, 32, 128, 1,               // 366:   decode to t2LDC2_OFFSET using decoder 128
                                             // 366:  }
  2, 7,                                      // 371:  case 0x2: {
  OPC_CheckPredicate, 73,                    // 373:   check predicate 73
  OPC_Decode, 229, 33, 128, 1,               // 375:   decode to t2STC2_PRE using decoder 128
                                             // 375:  }
  3, 7,                                      // 380:  case 0x3: {
  OPC_CheckPredicate, 73,                    // 382:   check predicate 73
  OPC_Decode, 153, 32, 128, 1,               // 384:   decode to t2LDC2_PRE using decoder 128
                                             // 384:  }
  4, 7,                                      // 389:  case 0x4: {
  OPC_CheckPredicate, 73,                    // 391:   check predicate 73
  OPC_Decode, 222, 33, 128, 1,               // 393:   decode to t2STC2L_OFFSET using decoder 128
                                             // 393:  }
  5, 7,                                      // 398:  case 0x5: {
  OPC_CheckPredicate, 73,                    // 400:   check predicate 73
  OPC_Decode, 146, 32, 128, 1,               // 402:   decode to t2LDC2L_OFFSET using decoder 128
                                             // 402:  }
  6, 7,                                      // 407:  case 0x6: {
  OPC_CheckPredicate, 73,                    // 409:   check predicate 73
  OPC_Decode, 225, 33, 128, 1,               // 411:   decode to t2STC2L_PRE using decoder 128
                                             // 411:  }
  7, 0,                                      // 416:  case 0x7: {
  OPC_CheckPredicate, 73,                    // 418:   check predicate 73
  OPC_Decode, 149, 32, 128, 1,               // 420:   decode to t2LDC2L_PRE using decoder 128
                                             // 420:  }
                                             // 420:  } // switch Inst[22:20]
                                             // 420: }
  254, 1, 0,                                 // 425: case 0xfe: {
  OPC_SwitchField, 4, 1,                     // 428:  switch Inst[4] {
  0, 7,                                      // 431:  case 0x0: {
  OPC_CheckPredicate, 72,                    // 433:   check predicate 72
  OPC_Decode, 228, 31, 223, 3,               // 435:   decode to t2CDP2 using decoder 479
                                             // 435:  }
  1, 0,                                      // 440:  case 0x1: {
  OPC_SwitchField, 20, 1,                    // 442:   switch Inst[20] {
  0, 7,                                      // 445:   case 0x0: {
  OPC_CheckPredicate, 72,                    // 447:    check predicate 72
  OPC_Decode, 216, 32, 224, 3,               // 449:    decode to t2MCR2 using decoder 480
                                             // 449:   }
  1, 0,                                      // 454:   case 0x1: {
  OPC_CheckPredicate, 72,                    // 456:    check predicate 72
  OPC_Decode, 226, 32, 225, 3,               // 458:    decode to t2MRC2 using decoder 481
                                             // 458:   }
                                             // 458:   } // switch Inst[20]
                                             // 458:  }
                                             // 458:  } // switch Inst[4]
                                             // 458: }
                                             // 458: } // switch Inst[31:24]
};
static const uint8_t DecoderTableVFP32[3466] = {
  OPC_SwitchField, 8, 4,                     //    0: switch Inst[11:8] {
  9, 168, 5,                                 //    3: case 0x9: {
  OPC_SwitchField, 20, 2,                    //    6:  switch Inst[21:20] {
  0, 79,                                     //    9:  case 0x0: {
  OPC_SwitchField, 24, 4,                    //   11:   switch Inst[27:24] {
  13, 7,                                     //   14:   case 0xd: {
  OPC_CheckPredicate, 74,                    //   16:    check predicate 74
  OPC_Decode, 175, 30, 226, 3,               //   18:    decode to VSTRH using decoder 482
                                             //   18:   }
  14, 0,                                     //   23:   case 0xe: {
  OPC_SwitchField, 4, 1,                     //   25:    switch Inst[4] {
  0, 39,                                     //   28:    case 0x0: {
  OPC_SwitchField, 6, 1,                     //   30:     switch Inst[6] {
  0, 21,                                     //   33:     case 0x0: {
  OPC_SwitchField, 23, 1,                    //   35:      switch Inst[23] {
  0, 7,                                      //   38:      case 0x0: {
  OPC_CheckPredicate, 75,                    //   40:       check predicate 75
  OPC_Decode, 139, 23, 227, 3,               //   42:       decode to VMLAH using decoder 483
                                             //   42:      }
  1, 0,                                      //   47:      case 0x1: {
  OPC_CheckPredicate, 75,                    //   49:       check predicate 75
  OPC_Decode, 138, 19, 228, 3,               //   51:       decode to VDIVH using decoder 484
                                             //   51:      }
                                             //   51:      } // switch Inst[23]
                                             //   51:     }
  1, 0,                                      //   56:     case 0x1: {
  OPC_CheckPredicate, 75,                    //   58:      check predicate 75
  OPC_CheckField, 23, 1, 0,                  //   60:      check Inst[23] == 0x0
  OPC_Decode, 170, 23, 227, 3,               //   64:      decode to VMLSH using decoder 483
                                             //   64:     }
                                             //   64:     } // switch Inst[6]
                                             //   64:    }
  1, 0,                                      //   69:    case 0x1: {
  OPC_CheckPredicate, 74,                    //   71:     check predicate 74
  OPC_CheckField, 22, 2, 0,                  //   73:     check Inst[23:22] == 0x0
  OPC_CheckField, 5, 2, 0,                   //   77:     check Inst[6:5] == 0x0
  OPC_CheckField, 0, 4, 0,                   //   81:     check Inst[3:0] == 0x0
  OPC_Decode, 204, 23, 229, 3,               //   85:     decode to VMOVHR using decoder 485
                                             //   85:    }
                                             //   85:    } // switch Inst[4]
                                             //   85:   }
                                             //   85:   } // switch Inst[27:24]
                                             //   85:  }
  1, 89,                                     //   90:  case 0x1: {
  OPC_SwitchField, 24, 4,                    //   92:   switch Inst[27:24] {
  13, 7,                                     //   95:   case 0xd: {
  OPC_CheckPredicate, 74,                    //   97:    check predicate 74
  OPC_Decode, 210, 22, 226, 3,               //   99:    decode to VLDRH using decoder 482
                                             //   99:   }
  14, 0,                                     //  104:   case 0xe: {
  OPC_SwitchField, 4, 1,                     //  106:    switch Inst[4] {
  0, 49,                                     //  109:    case 0x0: {
  OPC_SwitchField, 6, 1,                     //  111:     switch Inst[6] {
  0, 21,                                     //  114:     case 0x0: {
  OPC_SwitchField, 23, 1,                    //  116:      switch Inst[23] {
  0, 7,                                      //  119:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  121:       check predicate 75
  OPC_Decode, 184, 24, 227, 3,               //  123:       decode to VNMLSH using decoder 483
                                             //  123:      }
  1, 0,                                      //  128:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  130:       check predicate 75
  OPC_Decode, 187, 19, 227, 3,               //  132:       decode to VFNMSH using decoder 483
                                             //  132:      }
                                             //  132:      } // switch Inst[23]
                                             //  132:     }
  1, 0,                                      //  137:     case 0x1: {
  OPC_SwitchField, 23, 1,                    //  139:      switch Inst[23] {
  0, 7,                                      //  142:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  144:       check predicate 75
  OPC_Decode, 181, 24, 227, 3,               //  146:       decode to VNMLAH using decoder 483
                                             //  146:      }
  1, 0,                                      //  151:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  153:       check predicate 75
  OPC_Decode, 184, 19, 227, 3,               //  155:       decode to VFNMAH using decoder 483
                                             //  155:      }
                                             //  155:      } // switch Inst[23]
                                             //  155:     }
                                             //  155:     } // switch Inst[6]
                                             //  155:    }
  1, 0,                                      //  160:    case 0x1: {
  OPC_CheckPredicate, 74,                    //  162:     check predicate 74
  OPC_CheckField, 22, 2, 0,                  //  164:     check Inst[23:22] == 0x0
  OPC_CheckField, 5, 2, 0,                   //  168:     check Inst[6:5] == 0x0
  OPC_CheckField, 0, 4, 0,                   //  172:     check Inst[3:0] == 0x0
  OPC_Decode, 214, 23, 230, 3,               //  176:     decode to VMOVRH using decoder 486
                                             //  176:    }
                                             //  176:    } // switch Inst[4]
                                             //  176:   }
                                             //  176:   } // switch Inst[27:24]
                                             //  176:  }
  2, 65,                                     //  181:  case 0x2: {
  OPC_SwitchField, 6, 1,                     //  183:   switch Inst[6] {
  0, 29,                                     //  186:   case 0x0: {
  OPC_SwitchField, 23, 5,                    //  188:    switch Inst[27:23] {
  28, 11,                                    //  191:    case 0x1c: {
  OPC_CheckPredicate, 75,                    //  193:     check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  195:     check Inst[4] == 0x0
  OPC_Decode, 255, 23, 228, 3,               //  199:     decode to VMULH using decoder 484
                                             //  199:    }
  29, 0,                                     //  204:    case 0x1d: {
  OPC_CheckPredicate, 75,                    //  206:     check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  208:     check Inst[4] == 0x0
  OPC_Decode, 162, 19, 227, 3,               //  212:     decode to VFMAH using decoder 483
                                             //  212:    }
                                             //  212:    } // switch Inst[27:23]
                                             //  212:   }
  1, 0,                                      //  217:   case 0x1: {
  OPC_SwitchField, 23, 5,                    //  219:    switch Inst[27:23] {
  28, 11,                                    //  222:    case 0x1c: {
  OPC_CheckPredicate, 75,                    //  224:     check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  226:     check Inst[4] == 0x0
  OPC_Decode, 187, 24, 228, 3,               //  230:     decode to VNMULH using decoder 484
                                             //  230:    }
  29, 0,                                     //  235:    case 0x1d: {
  OPC_CheckPredicate, 75,                    //  237:     check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  239:     check Inst[4] == 0x0
  OPC_Decode, 173, 19, 227, 3,               //  243:     decode to VFMSH using decoder 483
                                             //  243:    }
                                             //  243:    } // switch Inst[27:23]
                                             //  243:   }
                                             //  243:   } // switch Inst[6]
                                             //  243:  }
  3, 0,                                      //  248:  case 0x3: {
  OPC_SwitchField, 6, 1,                     //  250:   switch Inst[6] {
  0, 33,                                     //  253:   case 0x0: {
  OPC_SwitchField, 23, 5,                    //  255:    switch Inst[27:23] {
  28, 11,                                    //  258:    case 0x1c: {
  OPC_CheckPredicate, 75,                    //  260:     check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  262:     check Inst[4] == 0x0
  OPC_Decode, 242, 16, 228, 3,               //  266:     decode to VADDH using decoder 484
                                             //  266:    }
  29, 0,                                     //  271:    case 0x1d: {
  OPC_CheckPredicate, 75,                    //  273:     check predicate 75
  OPC_CheckField, 7, 1, 0,                   //  275:     check Inst[7] == 0x0
  OPC_CheckField, 4, 2, 0,                   //  279:     check Inst[5:4] == 0x0
  OPC_Decode, 134, 7, 231, 3,                //  283:     decode to FCONSTH using decoder 487
                                             //  283:    }
                                             //  283:    } // switch Inst[27:23]
                                             //  283:   }
  1, 0,                                      //  288:   case 0x1: {
  OPC_SwitchField, 23, 5,                    //  290:    switch Inst[27:23] {
  28, 11,                                    //  293:    case 0x1c: {
  OPC_CheckPredicate, 75,                    //  295:     check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  297:     check Inst[4] == 0x0
  OPC_Decode, 196, 30, 228, 3,               //  301:     decode to VSUBH using decoder 484
                                             //  301:    }
  29, 0,                                     //  306:    case 0x1d: {
  OPC_SwitchField, 16, 4,                    //  308:     switch Inst[19:16] {
  0, 15,                                     //  311:     case 0x0: {
  OPC_CheckPredicate, 75,                    //  313:      check predicate 75
  OPC_CheckField, 7, 1, 1,                   //  315:      check Inst[7] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  319:      check Inst[4] == 0x0
  OPC_Decode, 221, 16, 232, 3,               //  323:      decode to VABSH using decoder 488
                                             //  323:     }
  1, 29,                                     //  328:     case 0x1: {
  OPC_SwitchField, 7, 1,                     //  330:      switch Inst[7] {
  0, 11,                                     //  333:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  335:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  337:       check Inst[4] == 0x0
  OPC_Decode, 168, 24, 232, 3,               //  341:       decode to VNEGH using decoder 488
                                             //  341:      }
  1, 0,                                      //  346:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  348:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  350:       check Inst[4] == 0x0
  OPC_Decode, 139, 28, 232, 3,               //  354:       decode to VSQRTH using decoder 488
                                             //  354:      }
                                             //  354:      } // switch Inst[7]
                                             //  354:     }
  4, 29,                                     //  359:     case 0x4: {
  OPC_SwitchField, 7, 1,                     //  361:      switch Inst[7] {
  0, 11,                                     //  364:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  366:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  368:       check Inst[4] == 0x0
  OPC_Decode, 158, 18, 232, 3,               //  372:       decode to VCMPH using decoder 488
                                             //  372:      }
  1, 0,                                      //  377:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  379:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  381:       check Inst[4] == 0x0
  OPC_Decode, 153, 18, 232, 3,               //  385:       decode to VCMPEH using decoder 488
                                             //  385:      }
                                             //  385:      } // switch Inst[7]
                                             //  385:     }
  5, 29,                                     //  390:     case 0x5: {
  OPC_SwitchField, 7, 1,                     //  392:      switch Inst[7] {
  0, 11,                                     //  395:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  397:       check predicate 75
  OPC_CheckField, 0, 6, 0,                   //  399:       check Inst[5:0] == 0x0
  OPC_Decode, 161, 18, 233, 3,               //  403:       decode to VCMPZH using decoder 489
                                             //  403:      }
  1, 0,                                      //  408:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  410:       check predicate 75
  OPC_CheckField, 0, 6, 0,                   //  412:       check Inst[5:0] == 0x0
  OPC_Decode, 156, 18, 233, 3,               //  416:       decode to VCMPEZH using decoder 489
                                             //  416:      }
                                             //  416:      } // switch Inst[7]
                                             //  416:     }
  6, 29,                                     //  421:     case 0x6: {
  OPC_SwitchField, 7, 1,                     //  423:      switch Inst[7] {
  0, 11,                                     //  426:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  428:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  430:       check Inst[4] == 0x0
  OPC_Decode, 223, 26, 232, 3,               //  434:       decode to VRINTRH using decoder 488
                                             //  434:      }
  1, 0,                                      //  439:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  441:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  443:       check Inst[4] == 0x0
  OPC_Decode, 233, 26, 232, 3,               //  447:       decode to VRINTZH using decoder 488
                                             //  447:      }
                                             //  447:      } // switch Inst[7]
                                             //  447:     }
  7, 15,                                     //  452:     case 0x7: {
  OPC_CheckPredicate, 75,                    //  454:      check predicate 75
  OPC_CheckField, 7, 1, 0,                   //  456:      check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  460:      check Inst[4] == 0x0
  OPC_Decode, 226, 26, 232, 3,               //  464:      decode to VRINTXH using decoder 488
                                             //  464:     }
  8, 29,                                     //  469:     case 0x8: {
  OPC_SwitchField, 7, 1,                     //  471:      switch Inst[7] {
  0, 11,                                     //  474:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  476:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  478:       check Inst[4] == 0x0
  OPC_Decode, 157, 31, 234, 3,               //  482:       decode to VUITOH using decoder 490
                                             //  482:      }
  1, 0,                                      //  487:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  489:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  491:       check Inst[4] == 0x0
  OPC_Decode, 252, 27, 234, 3,               //  495:       decode to VSITOH using decoder 490
                                             //  495:      }
                                             //  495:      } // switch Inst[7]
                                             //  495:     }
  10, 29,                                    //  500:     case 0xa: {
  OPC_SwitchField, 7, 1,                     //  502:      switch Inst[7] {
  0, 11,                                     //  505:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  507:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  509:       check Inst[4] == 0x0
  OPC_Decode, 249, 27, 235, 3,               //  513:       decode to VSHTOH using decoder 491
                                             //  513:      }
  1, 0,                                      //  518:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  520:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  522:       check Inst[4] == 0x0
  OPC_Decode, 135, 28, 235, 3,               //  526:       decode to VSLTOH using decoder 491
                                             //  526:      }
                                             //  526:      } // switch Inst[7]
                                             //  526:     }
  11, 29,                                    //  531:     case 0xb: {
  OPC_SwitchField, 7, 1,                     //  533:      switch Inst[7] {
  0, 11,                                     //  536:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  538:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  540:       check Inst[4] == 0x0
  OPC_Decode, 154, 31, 235, 3,               //  544:       decode to VUHTOH using decoder 491
                                             //  544:      }
  1, 0,                                      //  549:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  551:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  553:       check Inst[4] == 0x0
  OPC_Decode, 160, 31, 235, 3,               //  557:       decode to VULTOH using decoder 491
                                             //  557:      }
                                             //  557:      } // switch Inst[7]
                                             //  557:     }
  12, 29,                                    //  562:     case 0xc: {
  OPC_SwitchField, 7, 1,                     //  564:      switch Inst[7] {
  0, 11,                                     //  567:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  569:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  571:       check Inst[4] == 0x0
  OPC_Decode, 129, 31, 236, 3,               //  575:       decode to VTOUIRH using decoder 492
                                             //  575:      }
  1, 0,                                      //  580:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  582:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  584:       check Inst[4] == 0x0
  OPC_Decode, 132, 31, 237, 3,               //  588:       decode to VTOUIZH using decoder 493
                                             //  588:      }
                                             //  588:      } // switch Inst[7]
                                             //  588:     }
  13, 29,                                    //  593:     case 0xd: {
  OPC_SwitchField, 7, 1,                     //  595:      switch Inst[7] {
  0, 11,                                     //  598:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  600:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  602:       check Inst[4] == 0x0
  OPC_Decode, 245, 30, 236, 3,               //  606:       decode to VTOSIRH using decoder 492
                                             //  606:      }
  1, 0,                                      //  611:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  613:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  615:       check Inst[4] == 0x0
  OPC_Decode, 248, 30, 237, 3,               //  619:       decode to VTOSIZH using decoder 493
                                             //  619:      }
                                             //  619:      } // switch Inst[7]
                                             //  619:     }
  14, 29,                                    //  624:     case 0xe: {
  OPC_SwitchField, 7, 1,                     //  626:      switch Inst[7] {
  0, 11,                                     //  629:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  631:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  633:       check Inst[4] == 0x0
  OPC_Decode, 242, 30, 235, 3,               //  637:       decode to VTOSHH using decoder 491
                                             //  637:      }
  1, 0,                                      //  642:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  644:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  646:       check Inst[4] == 0x0
  OPC_Decode, 251, 30, 235, 3,               //  650:       decode to VTOSLH using decoder 491
                                             //  650:      }
                                             //  650:      } // switch Inst[7]
                                             //  650:     }
  15, 0,                                     //  655:     case 0xf: {
  OPC_SwitchField, 7, 1,                     //  657:      switch Inst[7] {
  0, 11,                                     //  660:      case 0x0: {
  OPC_CheckPredicate, 75,                    //  662:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  664:       check Inst[4] == 0x0
  OPC_Decode, 254, 30, 235, 3,               //  668:       decode to VTOUHH using decoder 491
                                             //  668:      }
  1, 0,                                      //  673:      case 0x1: {
  OPC_CheckPredicate, 75,                    //  675:       check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  677:       check Inst[4] == 0x0
  OPC_Decode, 135, 31, 235, 3,               //  681:       decode to VTOULH using decoder 491
                                             //  681:      }
                                             //  681:      } // switch Inst[7]
                                             //  681:     }
                                             //  681:     } // switch Inst[19:16]
                                             //  681:    }
                                             //  681:    } // switch Inst[27:23]
                                             //  681:   }
                                             //  681:   } // switch Inst[6]
                                             //  681:  }
                                             //  681:  } // switch Inst[21:20]
                                             //  681: }
  10, 211, 9,                                //  686: case 0xa: {
  OPC_SwitchField, 20, 2,                    //  689:  switch Inst[21:20] {
  0, 114,                                    //  692:  case 0x0: {
  OPC_SwitchField, 24, 4,                    //  694:   switch Inst[27:24] {
  12, 33,                                    //  697:   case 0xc: {
  OPC_SwitchField, 23, 1,                    //  699:    switch Inst[23] {
  0, 19,                                     //  702:    case 0x0: {
  OPC_CheckPredicate, 43,                    //  704:     check predicate 43
  OPC_CheckField, 22, 1, 1,                  //  706:     check Inst[22] == 0x1
  OPC_CheckField, 6, 2, 0,                   //  710:     check Inst[7:6] == 0x0
  OPC_CheckField, 4, 1, 1,                   //  714:     check Inst[4] == 0x1
  OPC_Decode, 220, 23, 238, 3,               //  718:     decode to VMOVSRR using decoder 494
                                             //  718:    }
  1, 0,                                      //  723:    case 0x1: {
  OPC_CheckPredicate, 43,                    //  725:     check predicate 43
  OPC_Decode, 172, 30, 239, 3,               //  727:     decode to VSTMSIA using decoder 495
                                             //  727:    }
                                             //  727:    } // switch Inst[23]
                                             //  727:   }
  13, 7,                                     //  732:   case 0xd: {
  OPC_CheckPredicate, 43,                    //  734:    check predicate 43
  OPC_Decode, 176, 30, 240, 3,               //  736:    decode to VSTRS using decoder 496
                                             //  736:   }
  14, 0,                                     //  741:   case 0xe: {
  OPC_SwitchField, 4, 1,                     //  743:    switch Inst[4] {
  0, 39,                                     //  746:    case 0x0: {
  OPC_SwitchField, 6, 1,                     //  748:     switch Inst[6] {
  0, 21,                                     //  751:     case 0x0: {
  OPC_SwitchField, 23, 1,                    //  753:      switch Inst[23] {
  0, 7,                                      //  756:      case 0x0: {
  OPC_CheckPredicate, 42,                    //  758:       check predicate 42
  OPC_Decode, 150, 23, 241, 3,               //  760:       decode to VMLAS using decoder 497
                                             //  760:      }
  1, 0,                                      //  765:      case 0x1: {
  OPC_CheckPredicate, 42,                    //  767:       check predicate 42
  OPC_Decode, 139, 19, 242, 3,               //  769:       decode to VDIVS using decoder 498
                                             //  769:      }
                                             //  769:      } // switch Inst[23]
                                             //  769:     }
  1, 0,                                      //  774:     case 0x1: {
  OPC_CheckPredicate, 42,                    //  776:      check predicate 42
  OPC_CheckField, 23, 1, 0,                  //  778:      check Inst[23] == 0x0
  OPC_Decode, 181, 23, 241, 3,               //  782:      decode to VMLSS using decoder 497
                                             //  782:     }
                                             //  782:     } // switch Inst[6]
                                             //  782:    }
  1, 0,                                      //  787:    case 0x1: {
  OPC_CheckPredicate, 43,                    //  789:     check predicate 43
  OPC_CheckField, 22, 2, 0,                  //  791:     check Inst[23:22] == 0x0
  OPC_CheckField, 5, 2, 0,                   //  795:     check Inst[6:5] == 0x0
  OPC_CheckField, 0, 4, 0,                   //  799:     check Inst[3:0] == 0x0
  OPC_Decode, 219, 23, 243, 3,               //  803:     decode to VMOVSR using decoder 499
                                             //  803:    }
                                             //  803:    } // switch Inst[4]
                                             //  803:   }
                                             //  803:   } // switch Inst[27:24]
                                             //  803:  }
  1, 141, 1,                                 //  808:  case 0x1: {
  OPC_SwitchField, 24, 4,                    //  811:   switch Inst[27:24] {
  12, 50,                                    //  814:   case 0xc: {
  OPC_SwitchField, 23, 1,                    //  816:    switch Inst[23] {
  0, 19,                                     //  819:    case 0x0: {
  OPC_CheckPredicate, 43,                    //  821:     check predicate 43
  OPC_CheckField, 22, 1, 1,                  //  823:     check Inst[22] == 0x1
  OPC_CheckField, 6, 2, 0,                   //  827:     check Inst[7:6] == 0x0
  OPC_CheckField, 4, 1, 1,                   //  831:     check Inst[4] == 0x1
  OPC_Decode, 216, 23, 244, 3,               //  835:     decode to VMOVRRS using decoder 500
                                             //  835:    }
  1, 0,                                      //  840:    case 0x1: {
  OPC_Scope, 15,                             //  842:     try {
  OPC_CheckField, 16, 4, 15,                 //  844:      check Inst[19:16] == 0xf
  OPC_CheckPredicate, 76,                    //  848:      check predicate 76
  OPC_CheckField, 28, 4, 14,                 //  850:      check Inst[31:28] == 0xe
  OPC_Decode, 176, 27, 245, 3,               //  854:      decode to VSCCLRMS using decoder 501
                                             //  854:     } else try {
  OPC_CheckPredicate, 43,                    //  859:      check predicate 43
  OPC_Decode, 207, 22, 239, 3,               //  861:      decode to VLDMSIA using decoder 495
                                             //  861:     }
                                             //  861:    }
                                             //  861:    } // switch Inst[23]
                                             //  861:   }
  13, 7,                                     //  866:   case 0xd: {
  OPC_CheckPredicate, 43,                    //  868:    check predicate 43
  OPC_Decode, 211, 22, 240, 3,               //  870:    decode to VLDRS using decoder 496
                                             //  870:   }
  14, 0,                                     //  875:   case 0xe: {
  OPC_SwitchField, 4, 1,                     //  877:    switch Inst[4] {
  0, 49,                                     //  880:    case 0x0: {
  OPC_SwitchField, 6, 1,                     //  882:     switch Inst[6] {
  0, 21,                                     //  885:     case 0x0: {
  OPC_SwitchField, 23, 1,                    //  887:      switch Inst[23] {
  0, 7,                                      //  890:      case 0x0: {
  OPC_CheckPredicate, 42,                    //  892:       check predicate 42
  OPC_Decode, 185, 24, 241, 3,               //  894:       decode to VNMLSS using decoder 497
                                             //  894:      }
  1, 0,                                      //  899:      case 0x1: {
  OPC_CheckPredicate, 77,                    //  901:       check predicate 77
  OPC_Decode, 188, 19, 241, 3,               //  903:       decode to VFNMSS using decoder 497
                                             //  903:      }
                                             //  903:      } // switch Inst[23]
                                             //  903:     }
  1, 0,                                      //  908:     case 0x1: {
  OPC_SwitchField, 23, 1,                    //  910:      switch Inst[23] {
  0, 7,                                      //  913:      case 0x0: {
  OPC_CheckPredicate, 42,                    //  915:       check predicate 42
  OPC_Decode, 182, 24, 241, 3,               //  917:       decode to VNMLAS using decoder 497
                                             //  917:      }
  1, 0,                                      //  922:      case 0x1: {
  OPC_CheckPredicate, 77,                    //  924:       check predicate 77
  OPC_Decode, 185, 19, 241, 3,               //  926:       decode to VFNMAS using decoder 497
                                             //  926:      }
                                             //  926:      } // switch Inst[23]
                                             //  926:     }
                                             //  926:     } // switch Inst[6]
                                             //  926:    }
  1, 0,                                      //  931:    case 0x1: {
  OPC_CheckPredicate, 43,                    //  933:     check predicate 43
  OPC_CheckField, 22, 2, 0,                  //  935:     check Inst[23:22] == 0x0
  OPC_CheckField, 5, 2, 0,                   //  939:     check Inst[6:5] == 0x0
  OPC_CheckField, 0, 4, 0,                   //  943:     check Inst[3:0] == 0x0
  OPC_Decode, 217, 23, 246, 3,               //  947:     decode to VMOVRS using decoder 502
                                             //  947:    }
                                             //  947:    } // switch Inst[4]
                                             //  947:   }
                                             //  947:   } // switch Inst[27:24]
                                             //  947:  }
  2, 175, 2,                                 //  952:  case 0x2: {
  OPC_SwitchField, 23, 5,                    //  955:   switch Inst[27:23] {
  24, 46,                                    //  958:   case 0x18: {
  OPC_SwitchField, 0, 8,                     //  960:    switch Inst[7:0] {
  0, 19,                                     //  963:    case 0x0: {
  OPC_CheckPredicate, 78,                    //  965:     check predicate 78
  OPC_CheckField, 28, 4, 14,                 //  967:     check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  //  971:     check Inst[22] == 0x0
  OPC_CheckField, 12, 4, 0,                  //  975:     check Inst[15:12] == 0x0
  OPC_Decode, 232, 22, 247, 3,               //  979:     decode to VLSTM using decoder 503
                                             //  979:    }
  128, 1, 0,                                 //  984:    case 0x80: {
  OPC_CheckPredicate, 76,                    //  987:     check predicate 76
  OPC_CheckField, 28, 4, 14,                 //  989:     check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  //  993:     check Inst[22] == 0x0
  OPC_CheckField, 12, 4, 0,                  //  997:     check Inst[15:12] == 0x0
  OPC_Decode, 233, 22, 247, 3,               // 1001:     decode to VLSTM_T2 using decoder 503
                                             // 1001:    }
                                             // 1001:    } // switch Inst[7:0]
                                             // 1001:   }
  25, 7,                                     // 1006:   case 0x19: {
  OPC_CheckPredicate, 43,                    // 1008:    check predicate 43
  OPC_Decode, 173, 30, 248, 3,               // 1010:    decode to VSTMSIA_UPD using decoder 504
                                             // 1010:   }
  26, 7,                                     // 1015:   case 0x1a: {
  OPC_CheckPredicate, 43,                    // 1017:    check predicate 43
  OPC_Decode, 171, 30, 248, 3,               // 1019:    decode to VSTMSDB_UPD using decoder 504
                                             // 1019:   }
  28, 29,                                    // 1024:   case 0x1c: {
  OPC_SwitchField, 6, 1,                     // 1026:    switch Inst[6] {
  0, 11,                                     // 1029:    case 0x0: {
  OPC_CheckPredicate, 42,                    // 1031:     check predicate 42
  OPC_CheckField, 4, 1, 0,                   // 1033:     check Inst[4] == 0x0
  OPC_Decode, 140, 24, 242, 3,               // 1037:     decode to VMULS using decoder 498
                                             // 1037:    }
  1, 0,                                      // 1042:    case 0x1: {
  OPC_CheckPredicate, 42,                    // 1044:     check predicate 42
  OPC_CheckField, 4, 1, 0,                   // 1046:     check Inst[4] == 0x0
  OPC_Decode, 188, 24, 242, 3,               // 1050:     decode to VNMULS using decoder 498
                                             // 1050:    }
                                             // 1050:    } // switch Inst[6]
                                             // 1050:   }
  29, 0,                                     // 1055:   case 0x1d: {
  OPC_SwitchField, 4, 1,                     // 1057:    switch Inst[4] {
  0, 21,                                     // 1060:    case 0x0: {
  OPC_SwitchField, 6, 1,                     // 1062:     switch Inst[6] {
  0, 7,                                      // 1065:     case 0x0: {
  OPC_CheckPredicate, 77,                    // 1067:      check predicate 77
  OPC_Decode, 167, 19, 241, 3,               // 1069:      decode to VFMAS using decoder 497
                                             // 1069:     }
  1, 0,                                      // 1074:     case 0x1: {
  OPC_CheckPredicate, 77,                    // 1076:      check predicate 77
  OPC_Decode, 178, 19, 241, 3,               // 1078:      decode to VFMSS using decoder 497
                                             // 1078:     }
                                             // 1078:     } // switch Inst[6]
                                             // 1078:    }
  1, 0,                                      // 1083:    case 0x1: {
  OPC_SwitchField, 16, 4,                    // 1085:     switch Inst[19:16] {
  0, 15,                                     // 1088:     case 0x0: {
  OPC_CheckPredicate, 42,                    // 1090:      check predicate 42
  OPC_CheckField, 22, 1, 1,                  // 1092:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1096:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 251, 23, 249, 3,               // 1100:      decode to VMSR_FPSID using decoder 505
                                             // 1100:     }
  1, 15,                                     // 1105:     case 0x1: {
  OPC_CheckPredicate, 43,                    // 1107:      check predicate 43
  OPC_CheckField, 22, 1, 1,                  // 1109:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1113:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 244, 23, 249, 3,               // 1117:      decode to VMSR using decoder 505
                                             // 1117:     }
  2, 15,                                     // 1122:     case 0x2: {
  OPC_CheckPredicate, 79,                    // 1124:      check predicate 79
  OPC_CheckField, 22, 1, 1,                  // 1126:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1130:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 250, 23, 249, 3,               // 1134:      decode to VMSR_FPSCR_NZCVQC using decoder 505
                                             // 1134:     }
  8, 15,                                     // 1139:     case 0x8: {
  OPC_CheckPredicate, 42,                    // 1141:      check predicate 42
  OPC_CheckField, 22, 1, 1,                  // 1143:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1147:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 247, 23, 249, 3,               // 1151:      decode to VMSR_FPEXC using decoder 505
                                             // 1151:     }
  9, 15,                                     // 1156:     case 0x9: {
  OPC_CheckPredicate, 42,                    // 1158:      check predicate 42
  OPC_CheckField, 22, 1, 1,                  // 1160:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1164:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 248, 23, 249, 3,               // 1168:      decode to VMSR_FPINST using decoder 505
                                             // 1168:     }
  10, 15,                                    // 1173:     case 0xa: {
  OPC_CheckPredicate, 42,                    // 1175:      check predicate 42
  OPC_CheckField, 22, 1, 1,                  // 1177:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1181:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 249, 23, 249, 3,               // 1185:      decode to VMSR_FPINST2 using decoder 505
                                             // 1185:     }
  12, 15,                                    // 1190:     case 0xc: {
  OPC_CheckPredicate, 32,                    // 1192:      check predicate 32
  OPC_CheckField, 22, 1, 1,                  // 1194:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1198:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 253, 23, 249, 3,               // 1202:      decode to VMSR_VPR using decoder 505
                                             // 1202:     }
  13, 15,                                    // 1207:     case 0xd: {
  OPC_CheckPredicate, 32,                    // 1209:      check predicate 32
  OPC_CheckField, 22, 1, 1,                  // 1211:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1215:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 252, 23, 249, 3,               // 1219:      decode to VMSR_P0 using decoder 505
                                             // 1219:     }
  14, 15,                                    // 1224:     case 0xe: {
  OPC_CheckPredicate, 76,                    // 1226:      check predicate 76
  OPC_CheckField, 22, 1, 1,                  // 1228:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1232:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 245, 23, 249, 3,               // 1236:      decode to VMSR_FPCXTNS using decoder 505
                                             // 1236:     }
  15, 0,                                     // 1241:     case 0xf: {
  OPC_CheckPredicate, 76,                    // 1243:      check predicate 76
  OPC_CheckField, 22, 1, 1,                  // 1245:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1249:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 246, 23, 249, 3,               // 1253:      decode to VMSR_FPCXTS using decoder 505
                                             // 1253:     }
                                             // 1253:     } // switch Inst[19:16]
                                             // 1253:    }
                                             // 1253:    } // switch Inst[4]
                                             // 1253:   }
                                             // 1253:   } // switch Inst[27:23]
                                             // 1253:  }
  3, 0,                                      // 1258:  case 0x3: {
  OPC_SwitchField, 23, 5,                    // 1260:   switch Inst[27:23] {
  24, 46,                                    // 1263:   case 0x18: {
  OPC_SwitchField, 0, 8,                     // 1265:    switch Inst[7:0] {
  0, 19,                                     // 1268:    case 0x0: {
  OPC_CheckPredicate, 78,                    // 1270:     check predicate 78
  OPC_CheckField, 28, 4, 14,                 // 1272:     check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  // 1276:     check Inst[22] == 0x0
  OPC_CheckField, 12, 4, 0,                  // 1280:     check Inst[15:12] == 0x0
  OPC_Decode, 230, 22, 247, 3,               // 1284:     decode to VLLDM using decoder 503
                                             // 1284:    }
  128, 1, 0,                                 // 1289:    case 0x80: {
  OPC_CheckPredicate, 76,                    // 1292:     check predicate 76
  OPC_CheckField, 28, 4, 14,                 // 1294:     check Inst[31:28] == 0xe
  OPC_CheckField, 22, 1, 0,                  // 1298:     check Inst[22] == 0x0
  OPC_CheckField, 12, 4, 0,                  // 1302:     check Inst[15:12] == 0x0
  OPC_Decode, 231, 22, 247, 3,               // 1306:     decode to VLLDM_T2 using decoder 503
                                             // 1306:    }
                                             // 1306:    } // switch Inst[7:0]
                                             // 1306:   }
  25, 7,                                     // 1311:   case 0x19: {
  OPC_CheckPredicate, 43,                    // 1313:    check predicate 43
  OPC_Decode, 208, 22, 248, 3,               // 1315:    decode to VLDMSIA_UPD using decoder 504
                                             // 1315:   }
  26, 7,                                     // 1320:   case 0x1a: {
  OPC_CheckPredicate, 43,                    // 1322:    check predicate 43
  OPC_Decode, 206, 22, 248, 3,               // 1324:    decode to VLDMSDB_UPD using decoder 504
                                             // 1324:   }
  28, 29,                                    // 1329:   case 0x1c: {
  OPC_SwitchField, 6, 1,                     // 1331:    switch Inst[6] {
  0, 11,                                     // 1334:    case 0x0: {
  OPC_CheckPredicate, 42,                    // 1336:     check predicate 42
  OPC_CheckField, 4, 1, 0,                   // 1338:     check Inst[4] == 0x0
  OPC_Decode, 252, 16, 242, 3,               // 1342:     decode to VADDS using decoder 498
                                             // 1342:    }
  1, 0,                                      // 1347:    case 0x1: {
  OPC_CheckPredicate, 42,                    // 1349:     check predicate 42
  OPC_CheckField, 4, 1, 0,                   // 1351:     check Inst[4] == 0x0
  OPC_Decode, 206, 30, 242, 3,               // 1355:     decode to VSUBS using decoder 498
                                             // 1355:    }
                                             // 1355:    } // switch Inst[6]
                                             // 1355:   }
  29, 0,                                     // 1360:   case 0x1d: {
  OPC_SwitchField, 4, 1,                     // 1362:    switch Inst[4] {
  0, 185, 2,                                 // 1365:    case 0x0: {
  OPC_SwitchField, 6, 2,                     // 1368:     switch Inst[7:6] {
  0, 11,                                     // 1371:     case 0x0: {
  OPC_CheckPredicate, 80,                    // 1373:      check predicate 80
  OPC_CheckField, 5, 1, 0,                   // 1375:      check Inst[5] == 0x0
  OPC_Decode, 135, 7, 250, 3,                // 1379:      decode to FCONSTS using decoder 506
                                             // 1379:     }
  1, 146, 1,                                 // 1384:     case 0x1: {
  OPC_SwitchField, 16, 4,                    // 1387:      switch Inst[19:16] {
  0, 7,                                      // 1390:      case 0x0: {
  OPC_CheckPredicate, 43,                    // 1392:       check predicate 43
  OPC_Decode, 218, 23, 236, 3,               // 1394:       decode to VMOVS using decoder 492
                                             // 1394:      }
  1, 7,                                      // 1399:      case 0x1: {
  OPC_CheckPredicate, 42,                    // 1401:       check predicate 42
  OPC_Decode, 169, 24, 236, 3,               // 1403:       decode to VNEGS using decoder 492
                                             // 1403:      }
  2, 7,                                      // 1408:      case 0x2: {
  OPC_CheckPredicate, 81,                    // 1410:       check predicate 81
  OPC_Decode, 181, 18, 236, 3,               // 1412:       decode to VCVTBHS using decoder 492
                                             // 1412:      }
  3, 7,                                      // 1417:      case 0x3: {
  OPC_CheckPredicate, 81,                    // 1419:       check predicate 81
  OPC_Decode, 182, 18, 251, 3,               // 1421:       decode to VCVTBSH using decoder 507
                                             // 1421:      }
  4, 7,                                      // 1426:      case 0x4: {
  OPC_CheckPredicate, 42,                    // 1428:       check predicate 42
  OPC_Decode, 159, 18, 236, 3,               // 1430:       decode to VCMPS using decoder 492
                                             // 1430:      }
  5, 15,                                     // 1435:      case 0x5: {
  OPC_CheckPredicate, 42,                    // 1437:       check predicate 42
  OPC_CheckField, 5, 1, 0,                   // 1439:       check Inst[5] == 0x0
  OPC_CheckField, 0, 4, 0,                   // 1443:       check Inst[3:0] == 0x0
  OPC_Decode, 162, 18, 252, 3,               // 1447:       decode to VCMPZS using decoder 508
                                             // 1447:      }
  6, 7,                                      // 1452:      case 0x6: {
  OPC_CheckPredicate, 82,                    // 1454:       check predicate 82
  OPC_Decode, 224, 26, 236, 3,               // 1456:       decode to VRINTRS using decoder 492
                                             // 1456:      }
  7, 7,                                      // 1461:      case 0x7: {
  OPC_CheckPredicate, 82,                    // 1463:       check predicate 82
  OPC_Decode, 231, 26, 236, 3,               // 1465:       decode to VRINTXS using decoder 492
                                             // 1465:      }
  8, 7,                                      // 1470:      case 0x8: {
  OPC_CheckPredicate, 42,                    // 1472:       check predicate 42
  OPC_Decode, 158, 31, 236, 3,               // 1474:       decode to VUITOS using decoder 492
                                             // 1474:      }
  10, 7,                                     // 1479:      case 0xa: {
  OPC_CheckPredicate, 42,                    // 1481:       check predicate 42
  OPC_Decode, 250, 27, 235, 3,               // 1483:       decode to VSHTOS using decoder 491
                                             // 1483:      }
  11, 7,                                     // 1488:      case 0xb: {
  OPC_CheckPredicate, 42,                    // 1490:       check predicate 42
  OPC_Decode, 155, 31, 235, 3,               // 1492:       decode to VUHTOS using decoder 491
                                             // 1492:      }
  12, 7,                                     // 1497:      case 0xc: {
  OPC_CheckPredicate, 42,                    // 1499:       check predicate 42
  OPC_Decode, 130, 31, 236, 3,               // 1501:       decode to VTOUIRS using decoder 492
                                             // 1501:      }
  13, 7,                                     // 1506:      case 0xd: {
  OPC_CheckPredicate, 42,                    // 1508:       check predicate 42
  OPC_Decode, 246, 30, 236, 3,               // 1510:       decode to VTOSIRS using decoder 492
                                             // 1510:      }
  14, 7,                                     // 1515:      case 0xe: {
  OPC_CheckPredicate, 42,                    // 1517:       check predicate 42
  OPC_Decode, 243, 30, 235, 3,               // 1519:       decode to VTOSHS using decoder 491
                                             // 1519:      }
  15, 0,                                     // 1524:      case 0xf: {
  OPC_CheckPredicate, 42,                    // 1526:       check predicate 42
  OPC_Decode, 255, 30, 235, 3,               // 1528:       decode to VTOUHS using decoder 491
                                             // 1528:      }
                                             // 1528:      } // switch Inst[19:16]
                                             // 1528:     }
  3, 0,                                      // 1533:     case 0x3: {
  OPC_SwitchField, 16, 4,                    // 1535:      switch Inst[19:16] {
  0, 7,                                      // 1538:      case 0x0: {
  OPC_CheckPredicate, 42,                    // 1540:       check predicate 42
  OPC_Decode, 222, 16, 236, 3,               // 1542:       decode to VABSS using decoder 492
                                             // 1542:      }
  1, 7,                                      // 1547:      case 0x1: {
  OPC_CheckPredicate, 42,                    // 1549:       check predicate 42
  OPC_Decode, 140, 28, 236, 3,               // 1551:       decode to VSQRTS using decoder 492
                                             // 1551:      }
  2, 7,                                      // 1556:      case 0x2: {
  OPC_CheckPredicate, 81,                    // 1558:       check predicate 81
  OPC_Decode, 229, 18, 236, 3,               // 1560:       decode to VCVTTHS using decoder 492
                                             // 1560:      }
  3, 7,                                      // 1565:      case 0x3: {
  OPC_CheckPredicate, 81,                    // 1567:       check predicate 81
  OPC_Decode, 230, 18, 251, 3,               // 1569:       decode to VCVTTSH using decoder 507
                                             // 1569:      }
  4, 7,                                      // 1574:      case 0x4: {
  OPC_CheckPredicate, 42,                    // 1576:       check predicate 42
  OPC_Decode, 154, 18, 236, 3,               // 1578:       decode to VCMPES using decoder 492
                                             // 1578:      }
  5, 15,                                     // 1583:      case 0x5: {
  OPC_CheckPredicate, 42,                    // 1585:       check predicate 42
  OPC_CheckField, 5, 1, 0,                   // 1587:       check Inst[5] == 0x0
  OPC_CheckField, 0, 4, 0,                   // 1591:       check Inst[3:0] == 0x0
  OPC_Decode, 157, 18, 252, 3,               // 1595:       decode to VCMPEZS using decoder 508
                                             // 1595:      }
  6, 7,                                      // 1600:      case 0x6: {
  OPC_CheckPredicate, 82,                    // 1602:       check predicate 82
  OPC_Decode, 238, 26, 236, 3,               // 1604:       decode to VRINTZS using decoder 492
                                             // 1604:      }
  7, 7,                                      // 1609:      case 0x7: {
  OPC_CheckPredicate, 83,                    // 1611:       check predicate 83
  OPC_Decode, 183, 18, 253, 3,               // 1613:       decode to VCVTDS using decoder 509
                                             // 1613:      }
  8, 7,                                      // 1618:      case 0x8: {
  OPC_CheckPredicate, 42,                    // 1620:       check predicate 42
  OPC_Decode, 253, 27, 236, 3,               // 1622:       decode to VSITOS using decoder 492
                                             // 1622:      }
  10, 7,                                     // 1627:      case 0xa: {
  OPC_CheckPredicate, 42,                    // 1629:       check predicate 42
  OPC_Decode, 136, 28, 235, 3,               // 1631:       decode to VSLTOS using decoder 491
                                             // 1631:      }
  11, 7,                                     // 1636:      case 0xb: {
  OPC_CheckPredicate, 42,                    // 1638:       check predicate 42
  OPC_Decode, 161, 31, 235, 3,               // 1640:       decode to VULTOS using decoder 491
                                             // 1640:      }
  12, 7,                                     // 1645:      case 0xc: {
  OPC_CheckPredicate, 42,                    // 1647:       check predicate 42
  OPC_Decode, 133, 31, 236, 3,               // 1649:       decode to VTOUIZS using decoder 492
                                             // 1649:      }
  13, 7,                                     // 1654:      case 0xd: {
  OPC_CheckPredicate, 42,                    // 1656:       check predicate 42
  OPC_Decode, 249, 30, 236, 3,               // 1658:       decode to VTOSIZS using decoder 492
                                             // 1658:      }
  14, 7,                                     // 1663:      case 0xe: {
  OPC_CheckPredicate, 42,                    // 1665:       check predicate 42
  OPC_Decode, 252, 30, 235, 3,               // 1667:       decode to VTOSLS using decoder 491
                                             // 1667:      }
  15, 0,                                     // 1672:      case 0xf: {
  OPC_CheckPredicate, 42,                    // 1674:       check predicate 42
  OPC_Decode, 136, 31, 235, 3,               // 1676:       decode to VTOULS using decoder 491
                                             // 1676:      }
                                             // 1676:      } // switch Inst[19:16]
                                             // 1676:     }
                                             // 1676:     } // switch Inst[7:6]
                                             // 1676:    }
  1, 0,                                      // 1681:    case 0x1: {
  OPC_SwitchField, 16, 4,                    // 1683:     switch Inst[19:16] {
  0, 15,                                     // 1686:     case 0x0: {
  OPC_CheckPredicate, 42,                    // 1688:      check predicate 42
  OPC_CheckField, 22, 1, 1,                  // 1690:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1694:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 238, 23, 249, 3,               // 1698:      decode to VMRS_FPSID using decoder 505
                                             // 1698:     }
  1, 32,                                     // 1703:     case 0x1: {
  OPC_CheckField, 22, 1, 1,                  // 1705:      check Inst[22] == 0x1
  OPC_Scope, 15,                             // 1709:      try {
  OPC_CheckField, 12, 4, 15,                 // 1711:       check Inst[15:12] == 0xf
  OPC_CheckPredicate, 43,                    // 1715:       check predicate 43
  OPC_SoftFail, 239, 1, 0,                   // 1717:       softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 139, 7, 249, 3,                // 1721:       decode to FMSTAT using decoder 505
                                             // 1721:      } else try {
  OPC_CheckPredicate, 43,                    // 1726:       check predicate 43
  OPC_SoftFail, 239, 1, 0,                   // 1728:       softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 231, 23, 249, 3,               // 1732:       decode to VMRS using decoder 505
                                             // 1732:      }
                                             // 1732:     }
  2, 15,                                     // 1737:     case 0x2: {
  OPC_CheckPredicate, 79,                    // 1739:      check predicate 79
  OPC_CheckField, 22, 1, 1,                  // 1741:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1745:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 237, 23, 249, 3,               // 1749:      decode to VMRS_FPSCR_NZCVQC using decoder 505
                                             // 1749:     }
  5, 15,                                     // 1754:     case 0x5: {
  OPC_CheckPredicate, 82,                    // 1756:      check predicate 82
  OPC_CheckField, 22, 1, 1,                  // 1758:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1762:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 241, 23, 249, 3,               // 1766:      decode to VMRS_MVFR2 using decoder 505
                                             // 1766:     }
  6, 15,                                     // 1771:     case 0x6: {
  OPC_CheckPredicate, 42,                    // 1773:      check predicate 42
  OPC_CheckField, 22, 1, 1,                  // 1775:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1779:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 240, 23, 249, 3,               // 1783:      decode to VMRS_MVFR1 using decoder 505
                                             // 1783:     }
  7, 15,                                     // 1788:     case 0x7: {
  OPC_CheckPredicate, 42,                    // 1790:      check predicate 42
  OPC_CheckField, 22, 1, 1,                  // 1792:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1796:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 239, 23, 249, 3,               // 1800:      decode to VMRS_MVFR0 using decoder 505
                                             // 1800:     }
  8, 15,                                     // 1805:     case 0x8: {
  OPC_CheckPredicate, 42,                    // 1807:      check predicate 42
  OPC_CheckField, 22, 1, 1,                  // 1809:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1813:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 234, 23, 249, 3,               // 1817:      decode to VMRS_FPEXC using decoder 505
                                             // 1817:     }
  9, 15,                                     // 1822:     case 0x9: {
  OPC_CheckPredicate, 42,                    // 1824:      check predicate 42
  OPC_CheckField, 22, 1, 1,                  // 1826:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1830:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 235, 23, 249, 3,               // 1834:      decode to VMRS_FPINST using decoder 505
                                             // 1834:     }
  10, 15,                                    // 1839:     case 0xa: {
  OPC_CheckPredicate, 42,                    // 1841:      check predicate 42
  OPC_CheckField, 22, 1, 1,                  // 1843:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1847:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 236, 23, 249, 3,               // 1851:      decode to VMRS_FPINST2 using decoder 505
                                             // 1851:     }
  12, 15,                                    // 1856:     case 0xc: {
  OPC_CheckPredicate, 32,                    // 1858:      check predicate 32
  OPC_CheckField, 22, 1, 1,                  // 1860:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1864:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 243, 23, 249, 3,               // 1868:      decode to VMRS_VPR using decoder 505
                                             // 1868:     }
  13, 15,                                    // 1873:     case 0xd: {
  OPC_CheckPredicate, 32,                    // 1875:      check predicate 32
  OPC_CheckField, 22, 1, 1,                  // 1877:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1881:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 242, 23, 249, 3,               // 1885:      decode to VMRS_P0 using decoder 505
                                             // 1885:     }
  14, 15,                                    // 1890:     case 0xe: {
  OPC_CheckPredicate, 76,                    // 1892:      check predicate 76
  OPC_CheckField, 22, 1, 1,                  // 1894:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1898:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 232, 23, 249, 3,               // 1902:      decode to VMRS_FPCXTNS using decoder 505
                                             // 1902:     }
  15, 0,                                     // 1907:     case 0xf: {
  OPC_CheckPredicate, 76,                    // 1909:      check predicate 76
  OPC_CheckField, 22, 1, 1,                  // 1911:      check Inst[22] == 0x1
  OPC_SoftFail, 239, 1, 0,                   // 1915:      softfail pos=0x000000ef neg=0x00000000
  OPC_Decode, 233, 23, 249, 3,               // 1919:      decode to VMRS_FPCXTS using decoder 505
                                             // 1919:     }
                                             // 1919:     } // switch Inst[19:16]
                                             // 1919:    }
                                             // 1919:    } // switch Inst[4]
                                             // 1919:   }
                                             // 1919:   } // switch Inst[27:23]
                                             // 1919:  }
                                             // 1919:  } // switch Inst[21:20]
                                             // 1919: }
  11, 150, 7,                                // 1924: case 0xb: {
  OPC_SwitchField, 20, 2,                    // 1927:  switch Inst[21:20] {
  0, 118,                                    // 1930:  case 0x0: {
  OPC_SwitchField, 24, 4,                    // 1932:   switch Inst[27:24] {
  12, 51,                                    // 1935:   case 0xc: {
  OPC_SwitchField, 23, 1,                    // 1937:    switch Inst[23] {
  0, 19,                                     // 1940:    case 0x0: {
  OPC_CheckPredicate, 43,                    // 1942:     check predicate 43
  OPC_CheckField, 22, 1, 1,                  // 1944:     check Inst[22] == 0x1
  OPC_CheckField, 6, 2, 0,                   // 1948:     check Inst[7:6] == 0x0
  OPC_CheckField, 4, 1, 1,                   // 1952:     check Inst[4] == 0x1
  OPC_Decode, 202, 23, 254, 3,               // 1956:     decode to VMOVDRR using decoder 510
                                             // 1956:    }
  1, 0,                                      // 1961:    case 0x1: {
  OPC_SwitchField, 0, 1,                     // 1963:     switch Inst[0] {
  0, 7,                                      // 1966:     case 0x0: {
  OPC_CheckPredicate, 43,                    // 1968:      check predicate 43
  OPC_Decode, 168, 30, 255, 3,               // 1970:      decode to VSTMDIA using decoder 511
                                             // 1970:     }
  1, 0,                                      // 1975:     case 0x1: {
  OPC_CheckPredicate, 43,                    // 1977:      check predicate 43
  OPC_CheckField, 22, 1, 0,                  // 1979:      check Inst[22] == 0x0
  OPC_Decode, 141, 7, 128, 4,                // 1983:      decode to FSTMXIA using decoder 512
                                             // 1983:     }
                                             // 1983:     } // switch Inst[0]
                                             // 1983:    }
                                             // 1983:    } // switch Inst[23]
                                             // 1983:   }
  13, 7,                                     // 1988:   case 0xd: {
  OPC_CheckPredicate, 43,                    // 1990:    check predicate 43
  OPC_Decode, 174, 30, 129, 4,               // 1992:    decode to VSTRD using decoder 513
                                             // 1992:   }
  14, 0,                                     // 1997:   case 0xe: {
  OPC_SwitchField, 6, 1,                     // 1999:    switch Inst[6] {
  0, 29,                                     // 2002:    case 0x0: {
  OPC_SwitchField, 23, 1,                    // 2004:     switch Inst[23] {
  0, 11,                                     // 2007:     case 0x0: {
  OPC_CheckPredicate, 83,                    // 2009:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2011:      check Inst[4] == 0x0
  OPC_Decode, 138, 23, 130, 4,               // 2015:      decode to VMLAD using decoder 514
                                             // 2015:     }
  1, 0,                                      // 2020:     case 0x1: {
  OPC_CheckPredicate, 83,                    // 2022:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2024:      check Inst[4] == 0x0
  OPC_Decode, 137, 19, 131, 4,               // 2028:      decode to VDIVD using decoder 515
                                             // 2028:     }
                                             // 2028:     } // switch Inst[23]
                                             // 2028:    }
  1, 0,                                      // 2033:    case 0x1: {
  OPC_CheckPredicate, 83,                    // 2035:     check predicate 83
  OPC_CheckField, 23, 1, 0,                  // 2037:     check Inst[23] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 2041:     check Inst[4] == 0x0
  OPC_Decode, 169, 23, 130, 4,               // 2045:     decode to VMLSD using decoder 514
                                             // 2045:    }
                                             // 2045:    } // switch Inst[6]
                                             // 2045:   }
                                             // 2045:   } // switch Inst[27:24]
                                             // 2045:  }
  1, 149, 1,                                 // 2050:  case 0x1: {
  OPC_SwitchField, 24, 4,                    // 2053:   switch Inst[27:24] {
  12, 68,                                    // 2056:   case 0xc: {
  OPC_SwitchField, 23, 1,                    // 2058:    switch Inst[23] {
  0, 19,                                     // 2061:    case 0x0: {
  OPC_CheckPredicate, 43,                    // 2063:     check predicate 43
  OPC_CheckField, 22, 1, 1,                  // 2065:     check Inst[22] == 0x1
  OPC_CheckField, 6, 2, 0,                   // 2069:     check Inst[7:6] == 0x0
  OPC_CheckField, 4, 1, 1,                   // 2073:     check Inst[4] == 0x1
  OPC_Decode, 215, 23, 132, 4,               // 2077:     decode to VMOVRRD using decoder 516
                                             // 2077:    }
  1, 0,                                      // 2082:    case 0x1: {
  OPC_SwitchField, 0, 1,                     // 2084:     switch Inst[0] {
  0, 24,                                     // 2087:     case 0x0: {
  OPC_Scope, 15,                             // 2089:      try {
  OPC_CheckField, 16, 4, 15,                 // 2091:       check Inst[19:16] == 0xf
  OPC_CheckPredicate, 76,                    // 2095:       check predicate 76
  OPC_CheckField, 28, 4, 14,                 // 2097:       check Inst[31:28] == 0xe
  OPC_Decode, 175, 27, 245, 3,               // 2101:       decode to VSCCLRMD using decoder 501
                                             // 2101:      } else try {
  OPC_CheckPredicate, 43,                    // 2106:       check predicate 43
  OPC_Decode, 203, 22, 255, 3,               // 2108:       decode to VLDMDIA using decoder 511
                                             // 2108:      }
                                             // 2108:     }
  1, 0,                                      // 2113:     case 0x1: {
  OPC_CheckPredicate, 43,                    // 2115:      check predicate 43
  OPC_CheckField, 22, 1, 0,                  // 2117:      check Inst[22] == 0x0
  OPC_Decode, 137, 7, 128, 4,                // 2121:      decode to FLDMXIA using decoder 512
                                             // 2121:     }
                                             // 2121:     } // switch Inst[0]
                                             // 2121:    }
                                             // 2121:    } // switch Inst[23]
                                             // 2121:   }
  13, 7,                                     // 2126:   case 0xd: {
  OPC_CheckPredicate, 43,                    // 2128:    check predicate 43
  OPC_Decode, 209, 22, 129, 4,               // 2130:    decode to VLDRD using decoder 513
                                             // 2130:   }
  14, 0,                                     // 2135:   case 0xe: {
  OPC_SwitchField, 6, 1,                     // 2137:    switch Inst[6] {
  0, 29,                                     // 2140:    case 0x0: {
  OPC_SwitchField, 23, 1,                    // 2142:     switch Inst[23] {
  0, 11,                                     // 2145:     case 0x0: {
  OPC_CheckPredicate, 83,                    // 2147:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2149:      check Inst[4] == 0x0
  OPC_Decode, 183, 24, 130, 4,               // 2153:      decode to VNMLSD using decoder 514
                                             // 2153:     }
  1, 0,                                      // 2158:     case 0x1: {
  OPC_CheckPredicate, 84,                    // 2160:      check predicate 84
  OPC_CheckField, 4, 1, 0,                   // 2162:      check Inst[4] == 0x0
  OPC_Decode, 186, 19, 130, 4,               // 2166:      decode to VFNMSD using decoder 514
                                             // 2166:     }
                                             // 2166:     } // switch Inst[23]
                                             // 2166:    }
  1, 0,                                      // 2171:    case 0x1: {
  OPC_SwitchField, 23, 1,                    // 2173:     switch Inst[23] {
  0, 11,                                     // 2176:     case 0x0: {
  OPC_CheckPredicate, 83,                    // 2178:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2180:      check Inst[4] == 0x0
  OPC_Decode, 180, 24, 130, 4,               // 2184:      decode to VNMLAD using decoder 514
                                             // 2184:     }
  1, 0,                                      // 2189:     case 0x1: {
  OPC_CheckPredicate, 84,                    // 2191:      check predicate 84
  OPC_CheckField, 4, 1, 0,                   // 2193:      check Inst[4] == 0x0
  OPC_Decode, 183, 19, 130, 4,               // 2197:      decode to VFNMAD using decoder 514
                                             // 2197:     }
                                             // 2197:     } // switch Inst[23]
                                             // 2197:    }
                                             // 2197:    } // switch Inst[6]
                                             // 2197:   }
                                             // 2197:   } // switch Inst[27:24]
                                             // 2197:  }
  2, 119,                                    // 2202:  case 0x2: {
  OPC_SwitchField, 23, 5,                    // 2204:   switch Inst[27:23] {
  25, 25,                                    // 2207:   case 0x19: {
  OPC_SwitchField, 0, 1,                     // 2209:    switch Inst[0] {
  0, 7,                                      // 2212:    case 0x0: {
  OPC_CheckPredicate, 43,                    // 2214:     check predicate 43
  OPC_Decode, 169, 30, 133, 4,               // 2216:     decode to VSTMDIA_UPD using decoder 517
                                             // 2216:    }
  1, 0,                                      // 2221:    case 0x1: {
  OPC_CheckPredicate, 43,                    // 2223:     check predicate 43
  OPC_CheckField, 22, 1, 0,                  // 2225:     check Inst[22] == 0x0
  OPC_Decode, 142, 7, 134, 4,                // 2229:     decode to FSTMXIA_UPD using decoder 518
                                             // 2229:    }
                                             // 2229:    } // switch Inst[0]
                                             // 2229:   }
  26, 25,                                    // 2234:   case 0x1a: {
  OPC_SwitchField, 0, 1,                     // 2236:    switch Inst[0] {
  0, 7,                                      // 2239:    case 0x0: {
  OPC_CheckPredicate, 43,                    // 2241:     check predicate 43
  OPC_Decode, 167, 30, 133, 4,               // 2243:     decode to VSTMDDB_UPD using decoder 517
                                             // 2243:    }
  1, 0,                                      // 2248:    case 0x1: {
  OPC_CheckPredicate, 43,                    // 2250:     check predicate 43
  OPC_CheckField, 22, 1, 0,                  // 2252:     check Inst[22] == 0x0
  OPC_Decode, 140, 7, 134, 4,                // 2256:     decode to FSTMXDB_UPD using decoder 518
                                             // 2256:    }
                                             // 2256:    } // switch Inst[0]
                                             // 2256:   }
  28, 29,                                    // 2261:   case 0x1c: {
  OPC_SwitchField, 6, 1,                     // 2263:    switch Inst[6] {
  0, 11,                                     // 2266:    case 0x0: {
  OPC_CheckPredicate, 83,                    // 2268:     check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2270:     check Inst[4] == 0x0
  OPC_Decode, 254, 23, 131, 4,               // 2274:     decode to VMULD using decoder 515
                                             // 2274:    }
  1, 0,                                      // 2279:    case 0x1: {
  OPC_CheckPredicate, 83,                    // 2281:     check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2283:     check Inst[4] == 0x0
  OPC_Decode, 186, 24, 131, 4,               // 2287:     decode to VNMULD using decoder 515
                                             // 2287:    }
                                             // 2287:    } // switch Inst[6]
                                             // 2287:   }
  29, 0,                                     // 2292:   case 0x1d: {
  OPC_SwitchField, 6, 1,                     // 2294:    switch Inst[6] {
  0, 11,                                     // 2297:    case 0x0: {
  OPC_CheckPredicate, 84,                    // 2299:     check predicate 84
  OPC_CheckField, 4, 1, 0,                   // 2301:     check Inst[4] == 0x0
  OPC_Decode, 161, 19, 130, 4,               // 2305:     decode to VFMAD using decoder 514
                                             // 2305:    }
  1, 0,                                      // 2310:    case 0x1: {
  OPC_CheckPredicate, 84,                    // 2312:     check predicate 84
  OPC_CheckField, 4, 1, 0,                   // 2314:     check Inst[4] == 0x0
  OPC_Decode, 172, 19, 130, 4,               // 2318:     decode to VFMSD using decoder 514
                                             // 2318:    }
                                             // 2318:    } // switch Inst[6]
                                             // 2318:   }
                                             // 2318:   } // switch Inst[27:23]
                                             // 2318:  }
  3, 0,                                      // 2323:  case 0x3: {
  OPC_SwitchField, 23, 5,                    // 2325:   switch Inst[27:23] {
  25, 25,                                    // 2328:   case 0x19: {
  OPC_SwitchField, 0, 1,                     // 2330:    switch Inst[0] {
  0, 7,                                      // 2333:    case 0x0: {
  OPC_CheckPredicate, 43,                    // 2335:     check predicate 43
  OPC_Decode, 204, 22, 133, 4,               // 2337:     decode to VLDMDIA_UPD using decoder 517
                                             // 2337:    }
  1, 0,                                      // 2342:    case 0x1: {
  OPC_CheckPredicate, 43,                    // 2344:     check predicate 43
  OPC_CheckField, 22, 1, 0,                  // 2346:     check Inst[22] == 0x0
  OPC_Decode, 138, 7, 134, 4,                // 2350:     decode to FLDMXIA_UPD using decoder 518
                                             // 2350:    }
                                             // 2350:    } // switch Inst[0]
                                             // 2350:   }
  26, 25,                                    // 2355:   case 0x1a: {
  OPC_SwitchField, 0, 1,                     // 2357:    switch Inst[0] {
  0, 7,                                      // 2360:    case 0x0: {
  OPC_CheckPredicate, 43,                    // 2362:     check predicate 43
  OPC_Decode, 202, 22, 133, 4,               // 2364:     decode to VLDMDDB_UPD using decoder 517
                                             // 2364:    }
  1, 0,                                      // 2369:    case 0x1: {
  OPC_CheckPredicate, 43,                    // 2371:     check predicate 43
  OPC_CheckField, 22, 1, 0,                  // 2373:     check Inst[22] == 0x0
  OPC_Decode, 136, 7, 134, 4,                // 2377:     decode to FLDMXDB_UPD using decoder 518
                                             // 2377:    }
                                             // 2377:    } // switch Inst[0]
                                             // 2377:   }
  28, 29,                                    // 2382:   case 0x1c: {
  OPC_SwitchField, 6, 1,                     // 2384:    switch Inst[6] {
  0, 11,                                     // 2387:    case 0x0: {
  OPC_CheckPredicate, 83,                    // 2389:     check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2391:     check Inst[4] == 0x0
  OPC_Decode, 241, 16, 131, 4,               // 2395:     decode to VADDD using decoder 515
                                             // 2395:    }
  1, 0,                                      // 2400:    case 0x1: {
  OPC_CheckPredicate, 83,                    // 2402:     check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2404:     check Inst[4] == 0x0
  OPC_Decode, 195, 30, 131, 4,               // 2408:     decode to VSUBD using decoder 515
                                             // 2408:    }
                                             // 2408:    } // switch Inst[6]
                                             // 2408:   }
  29, 0,                                     // 2413:   case 0x1d: {
  OPC_SwitchField, 6, 2,                     // 2415:    switch Inst[7:6] {
  0, 11,                                     // 2418:    case 0x0: {
  OPC_CheckPredicate, 85,                    // 2420:     check predicate 85
  OPC_CheckField, 4, 2, 0,                   // 2422:     check Inst[5:4] == 0x0
  OPC_Decode, 133, 7, 135, 4,                // 2426:     decode to FCONSTD using decoder 519
                                             // 2426:    }
  1, 198, 1,                                 // 2431:    case 0x1: {
  OPC_SwitchField, 16, 4,                    // 2434:     switch Inst[19:16] {
  0, 11,                                     // 2437:     case 0x0: {
  OPC_CheckPredicate, 86,                    // 2439:      check predicate 86
  OPC_CheckField, 4, 1, 0,                   // 2441:      check Inst[4] == 0x0
  OPC_Decode, 201, 23, 136, 4,               // 2445:      decode to VMOVD using decoder 520
                                             // 2445:     }
  1, 11,                                     // 2450:     case 0x1: {
  OPC_CheckPredicate, 83,                    // 2452:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2454:      check Inst[4] == 0x0
  OPC_Decode, 167, 24, 136, 4,               // 2458:      decode to VNEGD using decoder 520
                                             // 2458:     }
  2, 11,                                     // 2463:     case 0x2: {
  OPC_CheckPredicate, 87,                    // 2465:      check predicate 87
  OPC_CheckField, 4, 1, 0,                   // 2467:      check Inst[4] == 0x0
  OPC_Decode, 180, 18, 253, 3,               // 2471:      decode to VCVTBHD using decoder 509
                                             // 2471:     }
  3, 11,                                     // 2476:     case 0x3: {
  OPC_CheckPredicate, 87,                    // 2478:      check predicate 87
  OPC_CheckField, 4, 1, 0,                   // 2480:      check Inst[4] == 0x0
  OPC_Decode, 179, 18, 137, 4,               // 2484:      decode to VCVTBDH using decoder 521
                                             // 2484:     }
  4, 11,                                     // 2489:     case 0x4: {
  OPC_CheckPredicate, 83,                    // 2491:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2493:      check Inst[4] == 0x0
  OPC_Decode, 151, 18, 136, 4,               // 2497:      decode to VCMPD using decoder 520
                                             // 2497:     }
  5, 11,                                     // 2502:     case 0x5: {
  OPC_CheckPredicate, 83,                    // 2504:      check predicate 83
  OPC_CheckField, 0, 6, 0,                   // 2506:      check Inst[5:0] == 0x0
  OPC_Decode, 160, 18, 138, 4,               // 2510:      decode to VCMPZD using decoder 522
                                             // 2510:     }
  6, 11,                                     // 2515:     case 0x6: {
  OPC_CheckPredicate, 87,                    // 2517:      check predicate 87
  OPC_CheckField, 4, 1, 0,                   // 2519:      check Inst[4] == 0x0
  OPC_Decode, 222, 26, 136, 4,               // 2523:      decode to VRINTRD using decoder 520
                                             // 2523:     }
  7, 11,                                     // 2528:     case 0x7: {
  OPC_CheckPredicate, 87,                    // 2530:      check predicate 87
  OPC_CheckField, 4, 1, 0,                   // 2532:      check Inst[4] == 0x0
  OPC_Decode, 225, 26, 136, 4,               // 2536:      decode to VRINTXD using decoder 520
                                             // 2536:     }
  8, 11,                                     // 2541:     case 0x8: {
  OPC_CheckPredicate, 83,                    // 2543:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2545:      check Inst[4] == 0x0
  OPC_Decode, 156, 31, 253, 3,               // 2549:      decode to VUITOD using decoder 509
                                             // 2549:     }
  10, 11,                                    // 2554:     case 0xa: {
  OPC_CheckPredicate, 83,                    // 2556:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2558:      check Inst[4] == 0x0
  OPC_Decode, 248, 27, 139, 4,               // 2562:      decode to VSHTOD using decoder 523
                                             // 2562:     }
  11, 11,                                    // 2567:     case 0xb: {
  OPC_CheckPredicate, 83,                    // 2569:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2571:      check Inst[4] == 0x0
  OPC_Decode, 153, 31, 139, 4,               // 2575:      decode to VUHTOD using decoder 523
                                             // 2575:     }
  12, 11,                                    // 2580:     case 0xc: {
  OPC_CheckPredicate, 83,                    // 2582:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2584:      check Inst[4] == 0x0
  OPC_Decode, 128, 31, 140, 4,               // 2588:      decode to VTOUIRD using decoder 524
                                             // 2588:     }
  13, 11,                                    // 2593:     case 0xd: {
  OPC_CheckPredicate, 83,                    // 2595:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2597:      check Inst[4] == 0x0
  OPC_Decode, 244, 30, 140, 4,               // 2601:      decode to VTOSIRD using decoder 524
                                             // 2601:     }
  14, 11,                                    // 2606:     case 0xe: {
  OPC_CheckPredicate, 83,                    // 2608:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2610:      check Inst[4] == 0x0
  OPC_Decode, 241, 30, 139, 4,               // 2614:      decode to VTOSHD using decoder 523
                                             // 2614:     }
  15, 0,                                     // 2619:     case 0xf: {
  OPC_CheckPredicate, 83,                    // 2621:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2623:      check Inst[4] == 0x0
  OPC_Decode, 253, 30, 139, 4,               // 2627:      decode to VTOUHD using decoder 523
                                             // 2627:     }
                                             // 2627:     } // switch Inst[19:16]
                                             // 2627:    }
  3, 0,                                      // 2632:    case 0x3: {
  OPC_SwitchField, 16, 4,                    // 2634:     switch Inst[19:16] {
  0, 11,                                     // 2637:     case 0x0: {
  OPC_CheckPredicate, 83,                    // 2639:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2641:      check Inst[4] == 0x0
  OPC_Decode, 220, 16, 136, 4,               // 2645:      decode to VABSD using decoder 520
                                             // 2645:     }
  1, 11,                                     // 2650:     case 0x1: {
  OPC_CheckPredicate, 83,                    // 2652:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2654:      check Inst[4] == 0x0
  OPC_Decode, 138, 28, 136, 4,               // 2658:      decode to VSQRTD using decoder 520
                                             // 2658:     }
  2, 11,                                     // 2663:     case 0x2: {
  OPC_CheckPredicate, 87,                    // 2665:      check predicate 87
  OPC_CheckField, 4, 1, 0,                   // 2667:      check Inst[4] == 0x0
  OPC_Decode, 228, 18, 253, 3,               // 2671:      decode to VCVTTHD using decoder 509
                                             // 2671:     }
  3, 11,                                     // 2676:     case 0x3: {
  OPC_CheckPredicate, 87,                    // 2678:      check predicate 87
  OPC_CheckField, 4, 1, 0,                   // 2680:      check Inst[4] == 0x0
  OPC_Decode, 227, 18, 137, 4,               // 2684:      decode to VCVTTDH using decoder 521
                                             // 2684:     }
  4, 11,                                     // 2689:     case 0x4: {
  OPC_CheckPredicate, 83,                    // 2691:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2693:      check Inst[4] == 0x0
  OPC_Decode, 152, 18, 136, 4,               // 2697:      decode to VCMPED using decoder 520
                                             // 2697:     }
  5, 11,                                     // 2702:     case 0x5: {
  OPC_CheckPredicate, 83,                    // 2704:      check predicate 83
  OPC_CheckField, 0, 6, 0,                   // 2706:      check Inst[5:0] == 0x0
  OPC_Decode, 155, 18, 138, 4,               // 2710:      decode to VCMPEZD using decoder 522
                                             // 2710:     }
  6, 11,                                     // 2715:     case 0x6: {
  OPC_CheckPredicate, 87,                    // 2717:      check predicate 87
  OPC_CheckField, 4, 1, 0,                   // 2719:      check Inst[4] == 0x0
  OPC_Decode, 232, 26, 136, 4,               // 2723:      decode to VRINTZD using decoder 520
                                             // 2723:     }
  7, 11,                                     // 2728:     case 0x7: {
  OPC_CheckPredicate, 83,                    // 2730:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2732:      check Inst[4] == 0x0
  OPC_Decode, 226, 18, 140, 4,               // 2736:      decode to VCVTSD using decoder 524
                                             // 2736:     }
  8, 11,                                     // 2741:     case 0x8: {
  OPC_CheckPredicate, 83,                    // 2743:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2745:      check Inst[4] == 0x0
  OPC_Decode, 251, 27, 253, 3,               // 2749:      decode to VSITOD using decoder 509
                                             // 2749:     }
  9, 11,                                     // 2754:     case 0x9: {
  OPC_CheckPredicate, 88,                    // 2756:      check predicate 88
  OPC_CheckField, 4, 1, 0,                   // 2758:      check Inst[4] == 0x0
  OPC_Decode, 225, 19, 140, 4,               // 2762:      decode to VJCVT using decoder 524
                                             // 2762:     }
  10, 11,                                    // 2767:     case 0xa: {
  OPC_CheckPredicate, 83,                    // 2769:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2771:      check Inst[4] == 0x0
  OPC_Decode, 134, 28, 139, 4,               // 2775:      decode to VSLTOD using decoder 523
                                             // 2775:     }
  11, 11,                                    // 2780:     case 0xb: {
  OPC_CheckPredicate, 83,                    // 2782:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2784:      check Inst[4] == 0x0
  OPC_Decode, 159, 31, 139, 4,               // 2788:      decode to VULTOD using decoder 523
                                             // 2788:     }
  12, 11,                                    // 2793:     case 0xc: {
  OPC_CheckPredicate, 83,                    // 2795:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2797:      check Inst[4] == 0x0
  OPC_Decode, 131, 31, 140, 4,               // 2801:      decode to VTOUIZD using decoder 524
                                             // 2801:     }
  13, 11,                                    // 2806:     case 0xd: {
  OPC_CheckPredicate, 83,                    // 2808:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2810:      check Inst[4] == 0x0
  OPC_Decode, 247, 30, 140, 4,               // 2814:      decode to VTOSIZD using decoder 524
                                             // 2814:     }
  14, 11,                                    // 2819:     case 0xe: {
  OPC_CheckPredicate, 83,                    // 2821:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2823:      check Inst[4] == 0x0
  OPC_Decode, 250, 30, 139, 4,               // 2827:      decode to VTOSLD using decoder 523
                                             // 2827:     }
  15, 0,                                     // 2832:     case 0xf: {
  OPC_CheckPredicate, 83,                    // 2834:      check predicate 83
  OPC_CheckField, 4, 1, 0,                   // 2836:      check Inst[4] == 0x0
  OPC_Decode, 134, 31, 139, 4,               // 2840:      decode to VTOULD using decoder 523
                                             // 2840:     }
                                             // 2840:     } // switch Inst[19:16]
                                             // 2840:    }
                                             // 2840:    } // switch Inst[7:6]
                                             // 2840:   }
                                             // 2840:   } // switch Inst[27:23]
                                             // 2840:  }
                                             // 2840:  } // switch Inst[21:20]
                                             // 2840: }
  15, 0,                                     // 2845: case 0xf: {
  OPC_SwitchField, 20, 3,                    // 2847:  switch Inst[22:20] {
  0, 37,                                     // 2850:  case 0x0: {
  OPC_SwitchField, 12, 4,                    // 2852:   switch Inst[15:12] {
  2, 15,                                     // 2855:   case 0x2: {
  OPC_CheckPredicate, 34,                    // 2857:    check predicate 34
  OPC_CheckField, 24, 4, 13,                 // 2859:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 2863:    check Inst[7] == 0x1
  OPC_Decode, 186, 30, 141, 4,               // 2867:    decode to VSTR_FPSCR_off using decoder 525
                                             // 2867:   }
  4, 0,                                      // 2872:   case 0x4: {
  OPC_CheckPredicate, 34,                    // 2874:    check predicate 34
  OPC_CheckField, 24, 4, 13,                 // 2876:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 2880:    check Inst[7] == 0x1
  OPC_Decode, 183, 30, 141, 4,               // 2884:    decode to VSTR_FPSCR_NZCVQC_off using decoder 525
                                             // 2884:   }
                                             // 2884:   } // switch Inst[15:12]
                                             // 2884:  }
  1, 37,                                     // 2889:  case 0x1: {
  OPC_SwitchField, 12, 4,                    // 2891:   switch Inst[15:12] {
  2, 15,                                     // 2894:   case 0x2: {
  OPC_CheckPredicate, 34,                    // 2896:    check predicate 34
  OPC_CheckField, 24, 4, 13,                 // 2898:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 2902:    check Inst[7] == 0x1
  OPC_Decode, 221, 22, 141, 4,               // 2906:    decode to VLDR_FPSCR_off using decoder 525
                                             // 2906:   }
  4, 0,                                      // 2911:   case 0x4: {
  OPC_CheckPredicate, 34,                    // 2913:    check predicate 34
  OPC_CheckField, 24, 4, 13,                 // 2915:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 2919:    check Inst[7] == 0x1
  OPC_Decode, 218, 22, 141, 4,               // 2923:    decode to VLDR_FPSCR_NZCVQC_off using decoder 525
                                             // 2923:   }
                                             // 2923:   } // switch Inst[15:12]
                                             // 2923:  }
  2, 65,                                     // 2928:  case 0x2: {
  OPC_SwitchField, 12, 4,                    // 2930:   switch Inst[15:12] {
  2, 29,                                     // 2933:   case 0x2: {
  OPC_SwitchField, 24, 4,                    // 2935:    switch Inst[27:24] {
  12, 11,                                    // 2938:    case 0xc: {
  OPC_CheckPredicate, 34,                    // 2940:     check predicate 34
  OPC_CheckField, 7, 1, 1,                   // 2942:     check Inst[7] == 0x1
  OPC_Decode, 187, 30, 142, 4,               // 2946:     decode to VSTR_FPSCR_post using decoder 526
                                             // 2946:    }
  13, 0,                                     // 2951:    case 0xd: {
  OPC_CheckPredicate, 34,                    // 2953:     check predicate 34
  OPC_CheckField, 7, 1, 1,                   // 2955:     check Inst[7] == 0x1
  OPC_Decode, 188, 30, 142, 4,               // 2959:     decode to VSTR_FPSCR_pre using decoder 526
                                             // 2959:    }
                                             // 2959:    } // switch Inst[27:24]
                                             // 2959:   }
  4, 0,                                      // 2964:   case 0x4: {
  OPC_SwitchField, 24, 4,                    // 2966:    switch Inst[27:24] {
  12, 11,                                    // 2969:    case 0xc: {
  OPC_CheckPredicate, 34,                    // 2971:     check predicate 34
  OPC_CheckField, 7, 1, 1,                   // 2973:     check Inst[7] == 0x1
  OPC_Decode, 184, 30, 142, 4,               // 2977:     decode to VSTR_FPSCR_NZCVQC_post using decoder 526
                                             // 2977:    }
  13, 0,                                     // 2982:    case 0xd: {
  OPC_CheckPredicate, 34,                    // 2984:     check predicate 34
  OPC_CheckField, 7, 1, 1,                   // 2986:     check Inst[7] == 0x1
  OPC_Decode, 185, 30, 142, 4,               // 2990:     decode to VSTR_FPSCR_NZCVQC_pre using decoder 526
                                             // 2990:    }
                                             // 2990:    } // switch Inst[27:24]
                                             // 2990:   }
                                             // 2990:   } // switch Inst[15:12]
                                             // 2990:  }
  3, 65,                                     // 2995:  case 0x3: {
  OPC_SwitchField, 12, 4,                    // 2997:   switch Inst[15:12] {
  2, 29,                                     // 3000:   case 0x2: {
  OPC_SwitchField, 24, 4,                    // 3002:    switch Inst[27:24] {
  12, 11,                                    // 3005:    case 0xc: {
  OPC_CheckPredicate, 34,                    // 3007:     check predicate 34
  OPC_CheckField, 7, 1, 1,                   // 3009:     check Inst[7] == 0x1
  OPC_Decode, 222, 22, 142, 4,               // 3013:     decode to VLDR_FPSCR_post using decoder 526
                                             // 3013:    }
  13, 0,                                     // 3018:    case 0xd: {
  OPC_CheckPredicate, 34,                    // 3020:     check predicate 34
  OPC_CheckField, 7, 1, 1,                   // 3022:     check Inst[7] == 0x1
  OPC_Decode, 223, 22, 142, 4,               // 3026:     decode to VLDR_FPSCR_pre using decoder 526
                                             // 3026:    }
                                             // 3026:    } // switch Inst[27:24]
                                             // 3026:   }
  4, 0,                                      // 3031:   case 0x4: {
  OPC_SwitchField, 24, 4,                    // 3033:    switch Inst[27:24] {
  12, 11,                                    // 3036:    case 0xc: {
  OPC_CheckPredicate, 34,                    // 3038:     check predicate 34
  OPC_CheckField, 7, 1, 1,                   // 3040:     check Inst[7] == 0x1
  OPC_Decode, 219, 22, 142, 4,               // 3044:     decode to VLDR_FPSCR_NZCVQC_post using decoder 526
                                             // 3044:    }
  13, 0,                                     // 3049:    case 0xd: {
  OPC_CheckPredicate, 34,                    // 3051:     check predicate 34
  OPC_CheckField, 7, 1, 1,                   // 3053:     check Inst[7] == 0x1
  OPC_Decode, 220, 22, 142, 4,               // 3057:     decode to VLDR_FPSCR_NZCVQC_pre using decoder 526
                                             // 3057:    }
                                             // 3057:    } // switch Inst[27:24]
                                             // 3057:   }
                                             // 3057:   } // switch Inst[15:12]
                                             // 3057:  }
  4, 71,                                     // 3062:  case 0x4: {
  OPC_SwitchField, 12, 4,                    // 3064:   switch Inst[15:12] {
  8, 15,                                     // 3067:   case 0x8: {
  OPC_CheckPredicate, 32,                    // 3069:    check predicate 32
  OPC_CheckField, 24, 4, 13,                 // 3071:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 3075:    check Inst[7] == 0x1
  OPC_Decode, 192, 30, 141, 4,               // 3079:    decode to VSTR_VPR_off using decoder 525
                                             // 3079:   }
  10, 15,                                    // 3084:   case 0xa: {
  OPC_CheckPredicate, 32,                    // 3086:    check predicate 32
  OPC_CheckField, 24, 4, 13,                 // 3088:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 3092:    check Inst[7] == 0x1
  OPC_Decode, 189, 30, 141, 4,               // 3096:    decode to VSTR_P0_off using decoder 525
                                             // 3096:   }
  12, 15,                                    // 3101:   case 0xc: {
  OPC_CheckPredicate, 76,                    // 3103:    check predicate 76
  OPC_CheckField, 24, 4, 13,                 // 3105:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 3109:    check Inst[7] == 0x1
  OPC_Decode, 177, 30, 141, 4,               // 3113:    decode to VSTR_FPCXTNS_off using decoder 525
                                             // 3113:   }
  14, 0,                                     // 3118:   case 0xe: {
  OPC_CheckPredicate, 76,                    // 3120:    check predicate 76
  OPC_CheckField, 24, 4, 13,                 // 3122:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 3126:    check Inst[7] == 0x1
  OPC_Decode, 180, 30, 141, 4,               // 3130:    decode to VSTR_FPCXTS_off using decoder 525
                                             // 3130:   }
                                             // 3130:   } // switch Inst[15:12]
                                             // 3130:  }
  5, 71,                                     // 3135:  case 0x5: {
  OPC_SwitchField, 12, 4,                    // 3137:   switch Inst[15:12] {
  8, 15,                                     // 3140:   case 0x8: {
  OPC_CheckPredicate, 32,                    // 3142:    check predicate 32
  OPC_CheckField, 24, 4, 13,                 // 3144:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 3148:    check Inst[7] == 0x1
  OPC_Decode, 227, 22, 141, 4,               // 3152:    decode to VLDR_VPR_off using decoder 525
                                             // 3152:   }
  10, 15,                                    // 3157:   case 0xa: {
  OPC_CheckPredicate, 32,                    // 3159:    check predicate 32
  OPC_CheckField, 24, 4, 13,                 // 3161:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 3165:    check Inst[7] == 0x1
  OPC_Decode, 224, 22, 141, 4,               // 3169:    decode to VLDR_P0_off using decoder 525
                                             // 3169:   }
  12, 15,                                    // 3174:   case 0xc: {
  OPC_CheckPredicate, 76,                    // 3176:    check predicate 76
  OPC_CheckField, 24, 4, 13,                 // 3178:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 3182:    check Inst[7] == 0x1
  OPC_Decode, 212, 22, 141, 4,               // 3186:    decode to VLDR_FPCXTNS_off using decoder 525
                                             // 3186:   }
  14, 0,                                     // 3191:   case 0xe: {
  OPC_CheckPredicate, 76,                    // 3193:    check predicate 76
  OPC_CheckField, 24, 4, 13,                 // 3195:    check Inst[27:24] == 0xd
  OPC_CheckField, 7, 1, 1,                   // 3199:    check Inst[7] == 0x1
  OPC_Decode, 215, 22, 141, 4,               // 3203:    decode to VLDR_FPCXTS_off using decoder 525
                                             // 3203:   }
                                             // 3203:   } // switch Inst[15:12]
                                             // 3203:  }
  6, 127,                                    // 3208:  case 0x6: {
  OPC_SwitchField, 12, 4,                    // 3210:   switch Inst[15:12] {
  8, 29,                                     // 3213:   case 0x8: {
  OPC_SwitchField, 24, 4,                    // 3215:    switch Inst[27:24] {
  12, 11,                                    // 3218:    case 0xc: {
  OPC_CheckPredicate, 32,                    // 3220:     check predicate 32
  OPC_CheckField, 7, 1, 1,                   // 3222:     check Inst[7] == 0x1
  OPC_Decode, 193, 30, 142, 4,               // 3226:     decode to VSTR_VPR_post using decoder 526
                                             // 3226:    }
  13, 0,                                     // 3231:    case 0xd: {
  OPC_CheckPredicate, 32,                    // 3233:     check predicate 32
  OPC_CheckField, 7, 1, 1,                   // 3235:     check Inst[7] == 0x1
  OPC_Decode, 194, 30, 142, 4,               // 3239:     decode to VSTR_VPR_pre using decoder 526
                                             // 3239:    }
                                             // 3239:    } // switch Inst[27:24]
                                             // 3239:   }
  10, 29,                                    // 3244:   case 0xa: {
  OPC_SwitchField, 24, 4,                    // 3246:    switch Inst[27:24] {
  12, 11,                                    // 3249:    case 0xc: {
  OPC_CheckPredicate, 32,                    // 3251:     check predicate 32
  OPC_CheckField, 7, 1, 1,                   // 3253:     check Inst[7] == 0x1
  OPC_Decode, 190, 30, 142, 4,               // 3257:     decode to VSTR_P0_post using decoder 526
                                             // 3257:    }
  13, 0,                                     // 3262:    case 0xd: {
  OPC_CheckPredicate, 32,                    // 3264:     check predicate 32
  OPC_CheckField, 7, 1, 1,                   // 3266:     check Inst[7] == 0x1
  OPC_Decode, 191, 30, 142, 4,               // 3270:     decode to VSTR_P0_pre using decoder 526
                                             // 3270:    }
                                             // 3270:    } // switch Inst[27:24]
                                             // 3270:   }
  12, 29,                                    // 3275:   case 0xc: {
  OPC_SwitchField, 24, 4,                    // 3277:    switch Inst[27:24] {
  12, 11,                                    // 3280:    case 0xc: {
  OPC_CheckPredicate, 76,                    // 3282:     check predicate 76
  OPC_CheckField, 7, 1, 1,                   // 3284:     check Inst[7] == 0x1
  OPC_Decode, 178, 30, 142, 4,               // 3288:     decode to VSTR_FPCXTNS_post using decoder 526
                                             // 3288:    }
  13, 0,                                     // 3293:    case 0xd: {
  OPC_CheckPredicate, 76,                    // 3295:     check predicate 76
  OPC_CheckField, 7, 1, 1,                   // 3297:     check Inst[7] == 0x1
  OPC_Decode, 179, 30, 142, 4,               // 3301:     decode to VSTR_FPCXTNS_pre using decoder 526
                                             // 3301:    }
                                             // 3301:    } // switch Inst[27:24]
                                             // 3301:   }
  14, 0,                                     // 3306:   case 0xe: {
  OPC_SwitchField, 24, 4,                    // 3308:    switch Inst[27:24] {
  12, 11,                                    // 3311:    case 0xc: {
  OPC_CheckPredicate, 76,                    // 3313:     check predicate 76
  OPC_CheckField, 7, 1, 1,                   // 3315:     check Inst[7] == 0x1
  OPC_Decode, 181, 30, 142, 4,               // 3319:     decode to VSTR_FPCXTS_post using decoder 526
                                             // 3319:    }
  13, 0,                                     // 3324:    case 0xd: {
  OPC_CheckPredicate, 76,                    // 3326:     check predicate 76
  OPC_CheckField, 7, 1, 1,                   // 3328:     check Inst[7] == 0x1
  OPC_Decode, 182, 30, 142, 4,               // 3332:     decode to VSTR_FPCXTS_pre using decoder 526
                                             // 3332:    }
                                             // 3332:    } // switch Inst[27:24]
                                             // 3332:   }
                                             // 3332:   } // switch Inst[15:12]
                                             // 3332:  }
  7, 0,                                      // 3337:  case 0x7: {
  OPC_SwitchField, 12, 4,                    // 3339:   switch Inst[15:12] {
  8, 29,                                     // 3342:   case 0x8: {
  OPC_SwitchField, 24, 4,                    // 3344:    switch Inst[27:24] {
  12, 11,                                    // 3347:    case 0xc: {
  OPC_CheckPredicate, 32,                    // 3349:     check predicate 32
  OPC_CheckField, 7, 1, 1,                   // 3351:     check Inst[7] == 0x1
  OPC_Decode, 228, 22, 142, 4,               // 3355:     decode to VLDR_VPR_post using decoder 526
                                             // 3355:    }
  13, 0,                                     // 3360:    case 0xd: {
  OPC_CheckPredicate, 32,                    // 3362:     check predicate 32
  OPC_CheckField, 7, 1, 1,                   // 3364:     check Inst[7] == 0x1
  OPC_Decode, 229, 22, 142, 4,               // 3368:     decode to VLDR_VPR_pre using decoder 526
                                             // 3368:    }
                                             // 3368:    } // switch Inst[27:24]
                                             // 3368:   }
  10, 29,                                    // 3373:   case 0xa: {
  OPC_SwitchField, 24, 4,                    // 3375:    switch Inst[27:24] {
  12, 11,                                    // 3378:    case 0xc: {
  OPC_CheckPredicate, 32,                    // 3380:     check predicate 32
  OPC_CheckField, 7, 1, 1,                   // 3382:     check Inst[7] == 0x1
  OPC_Decode, 225, 22, 142, 4,               // 3386:     decode to VLDR_P0_post using decoder 526
                                             // 3386:    }
  13, 0,                                     // 3391:    case 0xd: {
  OPC_CheckPredicate, 32,                    // 3393:     check predicate 32
  OPC_CheckField, 7, 1, 1,                   // 3395:     check Inst[7] == 0x1
  OPC_Decode, 226, 22, 142, 4,               // 3399:     decode to VLDR_P0_pre using decoder 526
                                             // 3399:    }
                                             // 3399:    } // switch Inst[27:24]
                                             // 3399:   }
  12, 29,                                    // 3404:   case 0xc: {
  OPC_SwitchField, 24, 4,                    // 3406:    switch Inst[27:24] {
  12, 11,                                    // 3409:    case 0xc: {
  OPC_CheckPredicate, 76,                    // 3411:     check predicate 76
  OPC_CheckField, 7, 1, 1,                   // 3413:     check Inst[7] == 0x1
  OPC_Decode, 213, 22, 142, 4,               // 3417:     decode to VLDR_FPCXTNS_post using decoder 526
                                             // 3417:    }
  13, 0,                                     // 3422:    case 0xd: {
  OPC_CheckPredicate, 76,                    // 3424:     check predicate 76
  OPC_CheckField, 7, 1, 1,                   // 3426:     check Inst[7] == 0x1
  OPC_Decode, 214, 22, 142, 4,               // 3430:     decode to VLDR_FPCXTNS_pre using decoder 526
                                             // 3430:    }
                                             // 3430:    } // switch Inst[27:24]
                                             // 3430:   }
  14, 0,                                     // 3435:   case 0xe: {
  OPC_SwitchField, 24, 4,                    // 3437:    switch Inst[27:24] {
  12, 11,                                    // 3440:    case 0xc: {
  OPC_CheckPredicate, 76,                    // 3442:     check predicate 76
  OPC_CheckField, 7, 1, 1,                   // 3444:     check Inst[7] == 0x1
  OPC_Decode, 216, 22, 142, 4,               // 3448:     decode to VLDR_FPCXTS_post using decoder 526
                                             // 3448:    }
  13, 0,                                     // 3453:    case 0xd: {
  OPC_CheckPredicate, 76,                    // 3455:     check predicate 76
  OPC_CheckField, 7, 1, 1,                   // 3457:     check Inst[7] == 0x1
  OPC_Decode, 217, 22, 142, 4,               // 3461:     decode to VLDR_FPCXTS_pre using decoder 526
                                             // 3461:    }
                                             // 3461:    } // switch Inst[27:24]
                                             // 3461:   }
                                             // 3461:   } // switch Inst[15:12]
                                             // 3461:  }
                                             // 3461:  } // switch Inst[22:20]
                                             // 3461: }
                                             // 3461: } // switch Inst[11:8]
};
static const uint8_t DecoderTableVFPV832[1960] = {
  OPC_SwitchField, 8, 4,                     //    0: switch Inst[11:8] {
  8, 216, 2,                                 //    3: case 0x8: {
  OPC_SwitchField, 4, 1,                     //    6:  switch Inst[4] {
  0, 157, 1,                                 //    9:  case 0x0: {
  OPC_SwitchField, 6, 1,                     //   12:   switch Inst[6] {
  0, 75,                                     //   15:   case 0x0: {
  OPC_SwitchField, 25, 7,                    //   17:    switch Inst[31:25] {
  126, 47,                                   //   20:    case 0x7e: {
  OPC_SwitchField, 20, 2,                    //   22:     switch Inst[21:20] {
  0, 11,                                     //   25:     case 0x0: {
  OPC_CheckPredicate, 89,                    //   27:      check predicate 89
  OPC_CheckField, 23, 1, 1,                  //   29:      check Inst[23] == 0x1
  OPC_Decode, 164, 17, 143, 4,               //   33:      decode to VCADDv4f16 using decoder 527
                                             //   33:     }
  1, 11,                                     //   38:     case 0x1: {
  OPC_CheckPredicate, 90,                    //   40:      check predicate 90
  OPC_CheckField, 23, 1, 1,                  //   42:      check Inst[23] == 0x1
  OPC_Decode, 163, 17, 143, 4,               //   46:      decode to VCADDv2f32 using decoder 527
                                             //   46:     }
  2, 7,                                      //   51:     case 0x2: {
  OPC_CheckPredicate, 89,                    //   53:      check predicate 89
  OPC_Decode, 145, 18, 144, 4,               //   55:      decode to VCMLAv4f16 using decoder 528
                                             //   55:     }
  3, 0,                                      //   60:     case 0x3: {
  OPC_CheckPredicate, 90,                    //   62:      check predicate 90
  OPC_Decode, 143, 18, 144, 4,               //   64:      decode to VCMLAv2f32 using decoder 528
                                             //   64:     }
                                             //   64:     } // switch Inst[21:20]
                                             //   64:    }
  127, 0,                                    //   69:    case 0x7f: {
  OPC_SwitchField, 23, 2,                    //   71:     switch Inst[24:23] {
  0, 7,                                      //   74:     case 0x0: {
  OPC_CheckPredicate, 89,                    //   76:      check predicate 89
  OPC_Decode, 146, 18, 145, 4,               //   78:      decode to VCMLAv4f16_indexed using decoder 529
                                             //   78:     }
  1, 0,                                      //   83:     case 0x1: {
  OPC_CheckPredicate, 90,                    //   85:      check predicate 90
  OPC_Decode, 144, 18, 146, 4,               //   87:      decode to VCMLAv2f32_indexed using decoder 530
                                             //   87:     }
                                             //   87:     } // switch Inst[24:23]
                                             //   87:    }
                                             //   87:    } // switch Inst[31:25]
                                             //   87:   }
  1, 0,                                      //   92:   case 0x1: {
  OPC_SwitchField, 25, 7,                    //   94:    switch Inst[31:25] {
  126, 47,                                   //   97:    case 0x7e: {
  OPC_SwitchField, 20, 2,                    //   99:     switch Inst[21:20] {
  0, 11,                                     //  102:     case 0x0: {
  OPC_CheckPredicate, 89,                    //  104:      check predicate 89
  OPC_CheckField, 23, 1, 1,                  //  106:      check Inst[23] == 0x1
  OPC_Decode, 166, 17, 147, 4,               //  110:      decode to VCADDv8f16 using decoder 531
                                             //  110:     }
  1, 11,                                     //  115:     case 0x1: {
  OPC_CheckPredicate, 90,                    //  117:      check predicate 90
  OPC_CheckField, 23, 1, 1,                  //  119:      check Inst[23] == 0x1
  OPC_Decode, 165, 17, 147, 4,               //  123:      decode to VCADDv4f32 using decoder 531
                                             //  123:     }
  2, 7,                                      //  128:     case 0x2: {
  OPC_CheckPredicate, 89,                    //  130:      check predicate 89
  OPC_Decode, 149, 18, 148, 4,               //  132:      decode to VCMLAv8f16 using decoder 532
                                             //  132:     }
  3, 0,                                      //  137:     case 0x3: {
  OPC_CheckPredicate, 90,                    //  139:      check predicate 90
  OPC_Decode, 147, 18, 148, 4,               //  141:      decode to VCMLAv4f32 using decoder 532
                                             //  141:     }
                                             //  141:     } // switch Inst[21:20]
                                             //  141:    }
  127, 0,                                    //  146:    case 0x7f: {
  OPC_SwitchField, 23, 2,                    //  148:     switch Inst[24:23] {
  0, 7,                                      //  151:     case 0x0: {
  OPC_CheckPredicate, 89,                    //  153:      check predicate 89
  OPC_Decode, 150, 18, 149, 4,               //  155:      decode to VCMLAv8f16_indexed using decoder 533
                                             //  155:     }
  1, 0,                                      //  160:     case 0x1: {
  OPC_CheckPredicate, 90,                    //  162:      check predicate 90
  OPC_Decode, 148, 18, 146, 4,               //  164:      decode to VCMLAv4f32_indexed using decoder 530
                                             //  164:     }
                                             //  164:     } // switch Inst[24:23]
                                             //  164:    }
                                             //  164:    } // switch Inst[31:25]
                                             //  164:   }
                                             //  164:   } // switch Inst[6]
                                             //  164:  }
  1, 0,                                      //  169:  case 0x1: {
  OPC_SwitchField, 20, 2,                    //  171:   switch Inst[21:20] {
  0, 31,                                     //  174:   case 0x0: {
  OPC_SwitchField, 6, 1,                     //  176:    switch Inst[6] {
  0, 12,                                     //  179:    case 0x0: {
  OPC_CheckPredicate, 91,                    //  181:     check predicate 91
  OPC_CheckField, 23, 9, 252, 3,             //  183:     check Inst[31:23] == 0x1fc
  OPC_Decode, 164, 19, 150, 4,               //  188:     decode to VFMALDI using decoder 534
                                             //  188:    }
  1, 0,                                      //  193:    case 0x1: {
  OPC_CheckPredicate, 91,                    //  195:     check predicate 91
  OPC_CheckField, 23, 9, 252, 3,             //  197:     check Inst[31:23] == 0x1fc
  OPC_Decode, 166, 19, 151, 4,               //  202:     decode to VFMALQI using decoder 535
                                             //  202:    }
                                             //  202:    } // switch Inst[6]
                                             //  202:   }
  1, 31,                                     //  207:   case 0x1: {
  OPC_SwitchField, 6, 1,                     //  209:    switch Inst[6] {
  0, 12,                                     //  212:    case 0x0: {
  OPC_CheckPredicate, 91,                    //  214:     check predicate 91
  OPC_CheckField, 23, 9, 252, 3,             //  216:     check Inst[31:23] == 0x1fc
  OPC_Decode, 175, 19, 150, 4,               //  221:     decode to VFMSLDI using decoder 534
                                             //  221:    }
  1, 0,                                      //  226:    case 0x1: {
  OPC_CheckPredicate, 91,                    //  228:     check predicate 91
  OPC_CheckField, 23, 9, 252, 3,             //  230:     check Inst[31:23] == 0x1fc
  OPC_Decode, 177, 19, 151, 4,               //  235:     decode to VFMSLQI using decoder 535
                                             //  235:    }
                                             //  235:    } // switch Inst[6]
                                             //  235:   }
  2, 53,                                     //  240:   case 0x2: {
  OPC_SwitchField, 6, 1,                     //  242:    switch Inst[6] {
  0, 23,                                     //  245:    case 0x0: {
  OPC_SwitchField, 23, 9,                    //  247:     switch Inst[31:23] {
  248, 3, 7,                                 //  250:     case 0x1f8: {
  OPC_CheckPredicate, 91,                    //  253:      check predicate 91
  OPC_Decode, 163, 19, 152, 4,               //  255:      decode to VFMALD using decoder 536
                                             //  255:     }
  249, 3, 0,                                 //  260:     case 0x1f9: {
  OPC_CheckPredicate, 91,                    //  263:      check predicate 91
  OPC_Decode, 174, 19, 152, 4,               //  265:      decode to VFMSLD using decoder 536
                                             //  265:     }
                                             //  265:     } // switch Inst[31:23]
                                             //  265:    }
  1, 0,                                      //  270:    case 0x1: {
  OPC_SwitchField, 23, 9,                    //  272:     switch Inst[31:23] {
  248, 3, 7,                                 //  275:     case 0x1f8: {
  OPC_CheckPredicate, 91,                    //  278:      check predicate 91
  OPC_Decode, 165, 19, 132, 2,               //  280:      decode to VFMALQ using decoder 260
                                             //  280:     }
  249, 3, 0,                                 //  285:     case 0x1f9: {
  OPC_CheckPredicate, 91,                    //  288:      check predicate 91
  OPC_Decode, 176, 19, 132, 2,               //  290:      decode to VFMSLQ using decoder 260
                                             //  290:     }
                                             //  290:     } // switch Inst[31:23]
                                             //  290:    }
                                             //  290:    } // switch Inst[6]
                                             //  290:   }
  3, 0,                                      //  295:   case 0x3: {
  OPC_SwitchField, 6, 1,                     //  297:    switch Inst[6] {
  0, 23,                                     //  300:    case 0x0: {
  OPC_SwitchField, 23, 9,                    //  302:     switch Inst[31:23] {
  248, 3, 7,                                 //  305:     case 0x1f8: {
  OPC_CheckPredicate, 40,                    //  308:      check predicate 40
  OPC_Decode, 145, 17, 153, 4,               //  310:      decode to VBF16MALBQ using decoder 537
                                             //  310:     }
  252, 3, 0,                                 //  315:     case 0x1fc: {
  OPC_CheckPredicate, 40,                    //  318:      check predicate 40
  OPC_Decode, 146, 17, 154, 4,               //  320:      decode to VBF16MALBQI using decoder 538
                                             //  320:     }
                                             //  320:     } // switch Inst[31:23]
                                             //  320:    }
  1, 0,                                      //  325:    case 0x1: {
  OPC_SwitchField, 23, 9,                    //  327:     switch Inst[31:23] {
  248, 3, 7,                                 //  330:     case 0x1f8: {
  OPC_CheckPredicate, 40,                    //  333:      check predicate 40
  OPC_Decode, 147, 17, 153, 4,               //  335:      decode to VBF16MALTQ using decoder 537
                                             //  335:     }
  252, 3, 0,                                 //  340:     case 0x1fc: {
  OPC_CheckPredicate, 40,                    //  343:      check predicate 40
  OPC_Decode, 148, 17, 154, 4,               //  345:      decode to VBF16MALTQI using decoder 538
                                             //  345:     }
                                             //  345:     } // switch Inst[31:23]
                                             //  345:    }
                                             //  345:    } // switch Inst[6]
                                             //  345:   }
                                             //  345:   } // switch Inst[21:20]
                                             //  345:  }
                                             //  345:  } // switch Inst[4]
                                             //  345: }
  9, 166, 3,                                 //  350: case 0x9: {
  OPC_SwitchField, 20, 2,                    //  353:  switch Inst[21:20] {
  0, 54,                                     //  356:  case 0x0: {
  OPC_SwitchField, 6, 1,                     //  358:   switch Inst[6] {
  0, 31,                                     //  361:   case 0x0: {
  OPC_SwitchField, 23, 9,                    //  363:    switch Inst[31:23] {
  252, 3, 11,                                //  366:    case 0x1fc: {
  OPC_CheckPredicate, 75,                    //  369:     check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  371:     check Inst[4] == 0x0
  OPC_Decode, 182, 27, 155, 4,               //  375:     decode to VSELEQH using decoder 539
                                             //  375:    }
  253, 3, 0,                                 //  380:    case 0x1fd: {
  OPC_CheckPredicate, 75,                    //  383:     check predicate 75
  OPC_CheckField, 4, 1, 0,                   //  385:     check Inst[4] == 0x0
  OPC_Decode, 190, 19, 155, 4,               //  389:     decode to VFP_VMAXNMH using decoder 539
                                             //  389:    }
                                             //  389:    } // switch Inst[31:23]
                                             //  389:   }
  1, 0,                                      //  394:   case 0x1: {
  OPC_CheckPredicate, 75,                    //  396:    check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  398:    check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  403:    check Inst[4] == 0x0
  OPC_Decode, 193, 19, 155, 4,               //  407:    decode to VFP_VMINNMH using decoder 539
                                             //  407:   }
                                             //  407:   } // switch Inst[6]
                                             //  407:  }
  1, 20,                                     //  412:  case 0x1: {
  OPC_CheckPredicate, 75,                    //  414:   check predicate 75
  OPC_CheckField, 23, 9, 252, 3,             //  416:   check Inst[31:23] == 0x1fc
  OPC_CheckField, 6, 1, 0,                   //  421:   check Inst[6] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  425:   check Inst[4] == 0x0
  OPC_Decode, 191, 27, 155, 4,               //  429:   decode to VSELVSH using decoder 539
                                             //  429:  }
  2, 20,                                     //  434:  case 0x2: {
  OPC_CheckPredicate, 75,                    //  436:   check predicate 75
  OPC_CheckField, 23, 9, 252, 3,             //  438:   check Inst[31:23] == 0x1fc
  OPC_CheckField, 6, 1, 0,                   //  443:   check Inst[6] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  447:   check Inst[4] == 0x0
  OPC_Decode, 185, 27, 155, 4,               //  451:   decode to VSELGEH using decoder 539
                                             //  451:  }
  3, 0,                                      //  456:  case 0x3: {
  OPC_SwitchField, 6, 1,                     //  458:   switch Inst[6] {
  0, 16,                                     //  461:   case 0x0: {
  OPC_CheckPredicate, 75,                    //  463:    check predicate 75
  OPC_CheckField, 23, 9, 252, 3,             //  465:    check Inst[31:23] == 0x1fc
  OPC_CheckField, 4, 1, 0,                   //  470:    check Inst[4] == 0x0
  OPC_Decode, 188, 27, 155, 4,               //  474:    decode to VSELGTH using decoder 539
                                             //  474:   }
  1, 0,                                      //  479:   case 0x1: {
  OPC_SwitchField, 16, 4,                    //  481:    switch Inst[19:16] {
  3, 37,                                     //  484:    case 0x3: {
  OPC_SwitchField, 7, 1,                     //  486:     switch Inst[7] {
  0, 15,                                     //  489:     case 0x0: {
  OPC_CheckPredicate, 92,                    //  491:      check predicate 92
  OPC_CheckField, 23, 5, 29,                 //  493:      check Inst[27:23] == 0x1d
  OPC_CheckField, 4, 1, 0,                   //  497:      check Inst[4] == 0x0
  OPC_Decode, 183, 6, 251, 3,                //  501:      decode to BF16_VCVTB using decoder 507
                                             //  501:     }
  1, 0,                                      //  506:     case 0x1: {
  OPC_CheckPredicate, 92,                    //  508:      check predicate 92
  OPC_CheckField, 23, 5, 29,                 //  510:      check Inst[27:23] == 0x1d
  OPC_CheckField, 4, 1, 0,                   //  514:      check Inst[4] == 0x0
  OPC_Decode, 184, 6, 251, 3,                //  518:      decode to BF16_VCVTT using decoder 507
                                             //  518:     }
                                             //  518:     } // switch Inst[7]
                                             //  518:    }
  8, 20,                                     //  523:    case 0x8: {
  OPC_CheckPredicate, 75,                    //  525:     check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  527:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   //  532:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  536:     check Inst[4] == 0x0
  OPC_Decode, 195, 26, 156, 4,               //  540:     decode to VRINTAH using decoder 540
                                             //  540:    }
  9, 20,                                     //  545:    case 0x9: {
  OPC_CheckPredicate, 75,                    //  547:     check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  549:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   //  554:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  558:     check Inst[4] == 0x0
  OPC_Decode, 209, 26, 156, 4,               //  562:     decode to VRINTNH using decoder 540
                                             //  562:    }
  10, 20,                                    //  567:    case 0xa: {
  OPC_CheckPredicate, 75,                    //  569:     check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  571:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   //  576:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  580:     check Inst[4] == 0x0
  OPC_Decode, 216, 26, 156, 4,               //  584:     decode to VRINTPH using decoder 540
                                             //  584:    }
  11, 20,                                    //  589:    case 0xb: {
  OPC_CheckPredicate, 75,                    //  591:     check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  593:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   //  598:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  602:     check Inst[4] == 0x0
  OPC_Decode, 202, 26, 156, 4,               //  606:     decode to VRINTMH using decoder 540
                                             //  606:    }
  12, 39,                                    //  611:    case 0xc: {
  OPC_SwitchField, 7, 1,                     //  613:     switch Inst[7] {
  0, 16,                                     //  616:     case 0x0: {
  OPC_CheckPredicate, 75,                    //  618:      check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  620:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  625:      check Inst[4] == 0x0
  OPC_Decode, 177, 18, 157, 4,               //  629:      decode to VCVTAUH using decoder 541
                                             //  629:     }
  1, 0,                                      //  634:     case 0x1: {
  OPC_CheckPredicate, 75,                    //  636:      check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  638:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  643:      check Inst[4] == 0x0
  OPC_Decode, 174, 18, 157, 4,               //  647:      decode to VCVTASH using decoder 541
                                             //  647:     }
                                             //  647:     } // switch Inst[7]
                                             //  647:    }
  13, 39,                                    //  652:    case 0xd: {
  OPC_SwitchField, 7, 1,                     //  654:     switch Inst[7] {
  0, 16,                                     //  657:     case 0x0: {
  OPC_CheckPredicate, 75,                    //  659:      check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  661:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  666:      check Inst[4] == 0x0
  OPC_Decode, 210, 18, 157, 4,               //  670:      decode to VCVTNUH using decoder 541
                                             //  670:     }
  1, 0,                                      //  675:     case 0x1: {
  OPC_CheckPredicate, 75,                    //  677:      check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  679:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  684:      check Inst[4] == 0x0
  OPC_Decode, 207, 18, 157, 4,               //  688:      decode to VCVTNSH using decoder 541
                                             //  688:     }
                                             //  688:     } // switch Inst[7]
                                             //  688:    }
  14, 39,                                    //  693:    case 0xe: {
  OPC_SwitchField, 7, 1,                     //  695:     switch Inst[7] {
  0, 16,                                     //  698:     case 0x0: {
  OPC_CheckPredicate, 75,                    //  700:      check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  702:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  707:      check Inst[4] == 0x0
  OPC_Decode, 224, 18, 157, 4,               //  711:      decode to VCVTPUH using decoder 541
                                             //  711:     }
  1, 0,                                      //  716:     case 0x1: {
  OPC_CheckPredicate, 75,                    //  718:      check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  720:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  725:      check Inst[4] == 0x0
  OPC_Decode, 221, 18, 157, 4,               //  729:      decode to VCVTPSH using decoder 541
                                             //  729:     }
                                             //  729:     } // switch Inst[7]
                                             //  729:    }
  15, 0,                                     //  734:    case 0xf: {
  OPC_SwitchField, 7, 1,                     //  736:     switch Inst[7] {
  0, 16,                                     //  739:     case 0x0: {
  OPC_CheckPredicate, 75,                    //  741:      check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  743:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  748:      check Inst[4] == 0x0
  OPC_Decode, 196, 18, 157, 4,               //  752:      decode to VCVTMUH using decoder 541
                                             //  752:     }
  1, 0,                                      //  757:     case 0x1: {
  OPC_CheckPredicate, 75,                    //  759:      check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  761:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  766:      check Inst[4] == 0x0
  OPC_Decode, 193, 18, 157, 4,               //  770:      decode to VCVTMSH using decoder 541
                                             //  770:     }
                                             //  770:     } // switch Inst[7]
                                             //  770:    }
                                             //  770:    } // switch Inst[19:16]
                                             //  770:   }
                                             //  770:   } // switch Inst[6]
                                             //  770:  }
                                             //  770:  } // switch Inst[21:20]
                                             //  770: }
  10, 168, 3,                                //  775: case 0xa: {
  OPC_SwitchField, 20, 2,                    //  778:  switch Inst[21:20] {
  0, 54,                                     //  781:  case 0x0: {
  OPC_SwitchField, 6, 1,                     //  783:   switch Inst[6] {
  0, 31,                                     //  786:   case 0x0: {
  OPC_SwitchField, 23, 9,                    //  788:    switch Inst[31:23] {
  252, 3, 11,                                //  791:    case 0x1fc: {
  OPC_CheckPredicate, 82,                    //  794:     check predicate 82
  OPC_CheckField, 4, 1, 0,                   //  796:     check Inst[4] == 0x0
  OPC_Decode, 183, 27, 158, 4,               //  800:     decode to VSELEQS using decoder 542
                                             //  800:    }
  253, 3, 0,                                 //  805:    case 0x1fd: {
  OPC_CheckPredicate, 82,                    //  808:     check predicate 82
  OPC_CheckField, 4, 1, 0,                   //  810:     check Inst[4] == 0x0
  OPC_Decode, 191, 19, 158, 4,               //  814:     decode to VFP_VMAXNMS using decoder 542
                                             //  814:    }
                                             //  814:    } // switch Inst[31:23]
                                             //  814:   }
  1, 0,                                      //  819:   case 0x1: {
  OPC_CheckPredicate, 82,                    //  821:    check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             //  823:    check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  828:    check Inst[4] == 0x0
  OPC_Decode, 194, 19, 158, 4,               //  832:    decode to VFP_VMINNMS using decoder 542
                                             //  832:   }
                                             //  832:   } // switch Inst[6]
                                             //  832:  }
  1, 20,                                     //  837:  case 0x1: {
  OPC_CheckPredicate, 82,                    //  839:   check predicate 82
  OPC_CheckField, 23, 9, 252, 3,             //  841:   check Inst[31:23] == 0x1fc
  OPC_CheckField, 6, 1, 0,                   //  846:   check Inst[6] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  850:   check Inst[4] == 0x0
  OPC_Decode, 192, 27, 158, 4,               //  854:   decode to VSELVSS using decoder 542
                                             //  854:  }
  2, 20,                                     //  859:  case 0x2: {
  OPC_CheckPredicate, 82,                    //  861:   check predicate 82
  OPC_CheckField, 23, 9, 252, 3,             //  863:   check Inst[31:23] == 0x1fc
  OPC_CheckField, 6, 1, 0,                   //  868:   check Inst[6] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  872:   check Inst[4] == 0x0
  OPC_Decode, 186, 27, 158, 4,               //  876:   decode to VSELGES using decoder 542
                                             //  876:  }
  3, 0,                                      //  881:  case 0x3: {
  OPC_SwitchField, 6, 1,                     //  883:   switch Inst[6] {
  0, 16,                                     //  886:   case 0x0: {
  OPC_CheckPredicate, 82,                    //  888:    check predicate 82
  OPC_CheckField, 23, 9, 252, 3,             //  890:    check Inst[31:23] == 0x1fc
  OPC_CheckField, 4, 1, 0,                   //  895:    check Inst[4] == 0x0
  OPC_Decode, 189, 27, 158, 4,               //  899:    decode to VSELGTS using decoder 542
                                             //  899:   }
  1, 0,                                      //  904:   case 0x1: {
  OPC_SwitchField, 16, 4,                    //  906:    switch Inst[19:16] {
  0, 39,                                     //  909:    case 0x0: {
  OPC_SwitchField, 7, 1,                     //  911:     switch Inst[7] {
  0, 16,                                     //  914:     case 0x0: {
  OPC_CheckPredicate, 75,                    //  916:      check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  918:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  923:      check Inst[4] == 0x0
  OPC_Decode, 203, 23, 159, 4,               //  927:      decode to VMOVH using decoder 543
                                             //  927:     }
  1, 0,                                      //  932:     case 0x1: {
  OPC_CheckPredicate, 75,                    //  934:      check predicate 75
  OPC_CheckField, 23, 9, 253, 3,             //  936:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   //  941:      check Inst[4] == 0x0
  OPC_Decode, 224, 19, 160, 4,               //  945:      decode to VINSH using decoder 544
                                             //  945:     }
                                             //  945:     } // switch Inst[7]
                                             //  945:    }
  8, 20,                                     //  950:    case 0x8: {
  OPC_CheckPredicate, 82,                    //  952:     check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             //  954:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   //  959:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  963:     check Inst[4] == 0x0
  OPC_Decode, 200, 26, 159, 4,               //  967:     decode to VRINTAS using decoder 543
                                             //  967:    }
  9, 20,                                     //  972:    case 0x9: {
  OPC_CheckPredicate, 82,                    //  974:     check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             //  976:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   //  981:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   //  985:     check Inst[4] == 0x0
  OPC_Decode, 214, 26, 159, 4,               //  989:     decode to VRINTNS using decoder 543
                                             //  989:    }
  10, 20,                                    //  994:    case 0xa: {
  OPC_CheckPredicate, 82,                    //  996:     check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             //  998:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   // 1003:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 1007:     check Inst[4] == 0x0
  OPC_Decode, 221, 26, 159, 4,               // 1011:     decode to VRINTPS using decoder 543
                                             // 1011:    }
  11, 20,                                    // 1016:    case 0xb: {
  OPC_CheckPredicate, 82,                    // 1018:     check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             // 1020:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   // 1025:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 1029:     check Inst[4] == 0x0
  OPC_Decode, 207, 26, 159, 4,               // 1033:     decode to VRINTMS using decoder 543
                                             // 1033:    }
  12, 39,                                    // 1038:    case 0xc: {
  OPC_SwitchField, 7, 1,                     // 1040:     switch Inst[7] {
  0, 16,                                     // 1043:     case 0x0: {
  OPC_CheckPredicate, 82,                    // 1045:      check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             // 1047:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1052:      check Inst[4] == 0x0
  OPC_Decode, 178, 18, 159, 4,               // 1056:      decode to VCVTAUS using decoder 543
                                             // 1056:     }
  1, 0,                                      // 1061:     case 0x1: {
  OPC_CheckPredicate, 82,                    // 1063:      check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             // 1065:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1070:      check Inst[4] == 0x0
  OPC_Decode, 175, 18, 159, 4,               // 1074:      decode to VCVTASS using decoder 543
                                             // 1074:     }
                                             // 1074:     } // switch Inst[7]
                                             // 1074:    }
  13, 39,                                    // 1079:    case 0xd: {
  OPC_SwitchField, 7, 1,                     // 1081:     switch Inst[7] {
  0, 16,                                     // 1084:     case 0x0: {
  OPC_CheckPredicate, 82,                    // 1086:      check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             // 1088:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1093:      check Inst[4] == 0x0
  OPC_Decode, 211, 18, 159, 4,               // 1097:      decode to VCVTNUS using decoder 543
                                             // 1097:     }
  1, 0,                                      // 1102:     case 0x1: {
  OPC_CheckPredicate, 82,                    // 1104:      check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             // 1106:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1111:      check Inst[4] == 0x0
  OPC_Decode, 208, 18, 159, 4,               // 1115:      decode to VCVTNSS using decoder 543
                                             // 1115:     }
                                             // 1115:     } // switch Inst[7]
                                             // 1115:    }
  14, 39,                                    // 1120:    case 0xe: {
  OPC_SwitchField, 7, 1,                     // 1122:     switch Inst[7] {
  0, 16,                                     // 1125:     case 0x0: {
  OPC_CheckPredicate, 82,                    // 1127:      check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             // 1129:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1134:      check Inst[4] == 0x0
  OPC_Decode, 225, 18, 159, 4,               // 1138:      decode to VCVTPUS using decoder 543
                                             // 1138:     }
  1, 0,                                      // 1143:     case 0x1: {
  OPC_CheckPredicate, 82,                    // 1145:      check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             // 1147:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1152:      check Inst[4] == 0x0
  OPC_Decode, 222, 18, 159, 4,               // 1156:      decode to VCVTPSS using decoder 543
                                             // 1156:     }
                                             // 1156:     } // switch Inst[7]
                                             // 1156:    }
  15, 0,                                     // 1161:    case 0xf: {
  OPC_SwitchField, 7, 1,                     // 1163:     switch Inst[7] {
  0, 16,                                     // 1166:     case 0x0: {
  OPC_CheckPredicate, 82,                    // 1168:      check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             // 1170:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1175:      check Inst[4] == 0x0
  OPC_Decode, 197, 18, 159, 4,               // 1179:      decode to VCVTMUS using decoder 543
                                             // 1179:     }
  1, 0,                                      // 1184:     case 0x1: {
  OPC_CheckPredicate, 82,                    // 1186:      check predicate 82
  OPC_CheckField, 23, 9, 253, 3,             // 1188:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1193:      check Inst[4] == 0x0
  OPC_Decode, 194, 18, 159, 4,               // 1197:      decode to VCVTMSS using decoder 543
                                             // 1197:     }
                                             // 1197:     } // switch Inst[7]
                                             // 1197:    }
                                             // 1197:    } // switch Inst[19:16]
                                             // 1197:   }
                                             // 1197:   } // switch Inst[6]
                                             // 1197:  }
                                             // 1197:  } // switch Inst[21:20]
                                             // 1197: }
  11, 255, 2,                                // 1202: case 0xb: {
  OPC_SwitchField, 20, 2,                    // 1205:  switch Inst[21:20] {
  0, 54,                                     // 1208:  case 0x0: {
  OPC_SwitchField, 6, 1,                     // 1210:   switch Inst[6] {
  0, 31,                                     // 1213:   case 0x0: {
  OPC_SwitchField, 23, 9,                    // 1215:    switch Inst[31:23] {
  252, 3, 11,                                // 1218:    case 0x1fc: {
  OPC_CheckPredicate, 87,                    // 1221:     check predicate 87
  OPC_CheckField, 4, 1, 0,                   // 1223:     check Inst[4] == 0x0
  OPC_Decode, 181, 27, 161, 4,               // 1227:     decode to VSELEQD using decoder 545
                                             // 1227:    }
  253, 3, 0,                                 // 1232:    case 0x1fd: {
  OPC_CheckPredicate, 87,                    // 1235:     check predicate 87
  OPC_CheckField, 4, 1, 0,                   // 1237:     check Inst[4] == 0x0
  OPC_Decode, 189, 19, 161, 4,               // 1241:     decode to VFP_VMAXNMD using decoder 545
                                             // 1241:    }
                                             // 1241:    } // switch Inst[31:23]
                                             // 1241:   }
  1, 0,                                      // 1246:   case 0x1: {
  OPC_CheckPredicate, 87,                    // 1248:    check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1250:    check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1255:    check Inst[4] == 0x0
  OPC_Decode, 192, 19, 161, 4,               // 1259:    decode to VFP_VMINNMD using decoder 545
                                             // 1259:   }
                                             // 1259:   } // switch Inst[6]
                                             // 1259:  }
  1, 20,                                     // 1264:  case 0x1: {
  OPC_CheckPredicate, 87,                    // 1266:   check predicate 87
  OPC_CheckField, 23, 9, 252, 3,             // 1268:   check Inst[31:23] == 0x1fc
  OPC_CheckField, 6, 1, 0,                   // 1273:   check Inst[6] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 1277:   check Inst[4] == 0x0
  OPC_Decode, 190, 27, 161, 4,               // 1281:   decode to VSELVSD using decoder 545
                                             // 1281:  }
  2, 20,                                     // 1286:  case 0x2: {
  OPC_CheckPredicate, 87,                    // 1288:   check predicate 87
  OPC_CheckField, 23, 9, 252, 3,             // 1290:   check Inst[31:23] == 0x1fc
  OPC_CheckField, 6, 1, 0,                   // 1295:   check Inst[6] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 1299:   check Inst[4] == 0x0
  OPC_Decode, 184, 27, 161, 4,               // 1303:   decode to VSELGED using decoder 545
                                             // 1303:  }
  3, 0,                                      // 1308:  case 0x3: {
  OPC_SwitchField, 6, 1,                     // 1310:   switch Inst[6] {
  0, 16,                                     // 1313:   case 0x0: {
  OPC_CheckPredicate, 87,                    // 1315:    check predicate 87
  OPC_CheckField, 23, 9, 252, 3,             // 1317:    check Inst[31:23] == 0x1fc
  OPC_CheckField, 4, 1, 0,                   // 1322:    check Inst[4] == 0x0
  OPC_Decode, 187, 27, 161, 4,               // 1326:    decode to VSELGTD using decoder 545
                                             // 1326:   }
  1, 0,                                      // 1331:   case 0x1: {
  OPC_SwitchField, 16, 4,                    // 1333:    switch Inst[19:16] {
  8, 20,                                     // 1336:    case 0x8: {
  OPC_CheckPredicate, 87,                    // 1338:     check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1340:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   // 1345:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 1349:     check Inst[4] == 0x0
  OPC_Decode, 194, 26, 162, 4,               // 1353:     decode to VRINTAD using decoder 546
                                             // 1353:    }
  9, 20,                                     // 1358:    case 0x9: {
  OPC_CheckPredicate, 87,                    // 1360:     check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1362:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   // 1367:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 1371:     check Inst[4] == 0x0
  OPC_Decode, 208, 26, 162, 4,               // 1375:     decode to VRINTND using decoder 546
                                             // 1375:    }
  10, 20,                                    // 1380:    case 0xa: {
  OPC_CheckPredicate, 87,                    // 1382:     check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1384:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   // 1389:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 1393:     check Inst[4] == 0x0
  OPC_Decode, 215, 26, 162, 4,               // 1397:     decode to VRINTPD using decoder 546
                                             // 1397:    }
  11, 20,                                    // 1402:    case 0xb: {
  OPC_CheckPredicate, 87,                    // 1404:     check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1406:     check Inst[31:23] == 0x1fd
  OPC_CheckField, 7, 1, 0,                   // 1411:     check Inst[7] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 1415:     check Inst[4] == 0x0
  OPC_Decode, 201, 26, 162, 4,               // 1419:     decode to VRINTMD using decoder 546
                                             // 1419:    }
  12, 39,                                    // 1424:    case 0xc: {
  OPC_SwitchField, 7, 1,                     // 1426:     switch Inst[7] {
  0, 16,                                     // 1429:     case 0x0: {
  OPC_CheckPredicate, 87,                    // 1431:      check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1433:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1438:      check Inst[4] == 0x0
  OPC_Decode, 176, 18, 163, 4,               // 1442:      decode to VCVTAUD using decoder 547
                                             // 1442:     }
  1, 0,                                      // 1447:     case 0x1: {
  OPC_CheckPredicate, 87,                    // 1449:      check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1451:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1456:      check Inst[4] == 0x0
  OPC_Decode, 173, 18, 163, 4,               // 1460:      decode to VCVTASD using decoder 547
                                             // 1460:     }
                                             // 1460:     } // switch Inst[7]
                                             // 1460:    }
  13, 39,                                    // 1465:    case 0xd: {
  OPC_SwitchField, 7, 1,                     // 1467:     switch Inst[7] {
  0, 16,                                     // 1470:     case 0x0: {
  OPC_CheckPredicate, 87,                    // 1472:      check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1474:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1479:      check Inst[4] == 0x0
  OPC_Decode, 209, 18, 163, 4,               // 1483:      decode to VCVTNUD using decoder 547
                                             // 1483:     }
  1, 0,                                      // 1488:     case 0x1: {
  OPC_CheckPredicate, 87,                    // 1490:      check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1492:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1497:      check Inst[4] == 0x0
  OPC_Decode, 206, 18, 163, 4,               // 1501:      decode to VCVTNSD using decoder 547
                                             // 1501:     }
                                             // 1501:     } // switch Inst[7]
                                             // 1501:    }
  14, 39,                                    // 1506:    case 0xe: {
  OPC_SwitchField, 7, 1,                     // 1508:     switch Inst[7] {
  0, 16,                                     // 1511:     case 0x0: {
  OPC_CheckPredicate, 87,                    // 1513:      check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1515:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1520:      check Inst[4] == 0x0
  OPC_Decode, 223, 18, 163, 4,               // 1524:      decode to VCVTPUD using decoder 547
                                             // 1524:     }
  1, 0,                                      // 1529:     case 0x1: {
  OPC_CheckPredicate, 87,                    // 1531:      check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1533:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1538:      check Inst[4] == 0x0
  OPC_Decode, 220, 18, 163, 4,               // 1542:      decode to VCVTPSD using decoder 547
                                             // 1542:     }
                                             // 1542:     } // switch Inst[7]
                                             // 1542:    }
  15, 0,                                     // 1547:    case 0xf: {
  OPC_SwitchField, 7, 1,                     // 1549:     switch Inst[7] {
  0, 16,                                     // 1552:     case 0x0: {
  OPC_CheckPredicate, 87,                    // 1554:      check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1556:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1561:      check Inst[4] == 0x0
  OPC_Decode, 195, 18, 163, 4,               // 1565:      decode to VCVTMUD using decoder 547
                                             // 1565:     }
  1, 0,                                      // 1570:     case 0x1: {
  OPC_CheckPredicate, 87,                    // 1572:      check predicate 87
  OPC_CheckField, 23, 9, 253, 3,             // 1574:      check Inst[31:23] == 0x1fd
  OPC_CheckField, 4, 1, 0,                   // 1579:      check Inst[4] == 0x0
  OPC_Decode, 192, 18, 163, 4,               // 1583:      decode to VCVTMSD using decoder 547
                                             // 1583:     }
                                             // 1583:     } // switch Inst[7]
                                             // 1583:    }
                                             // 1583:    } // switch Inst[19:16]
                                             // 1583:   }
                                             // 1583:   } // switch Inst[6]
                                             // 1583:  }
                                             // 1583:  } // switch Inst[21:20]
                                             // 1583: }
  12, 81,                                    // 1588: case 0xc: {
  OPC_SwitchField, 4, 1,                     // 1590:  switch Inst[4] {
  0, 54,                                     // 1593:  case 0x0: {
  OPC_SwitchField, 20, 2,                    // 1595:   switch Inst[21:20] {
  0, 16,                                     // 1598:   case 0x0: {
  OPC_CheckPredicate, 40,                    // 1600:    check predicate 40
  OPC_CheckField, 23, 9, 248, 3,             // 1602:    check Inst[31:23] == 0x1f8
  OPC_CheckField, 6, 1, 1,                   // 1607:    check Inst[6] == 0x1
  OPC_Decode, 200, 23, 153, 4,               // 1611:    decode to VMMLA using decoder 537
                                             // 1611:   }
  2, 0,                                      // 1616:   case 0x2: {
  OPC_SwitchField, 23, 9,                    // 1618:    switch Inst[31:23] {
  248, 3, 11,                                // 1621:    case 0x1f8: {
  OPC_CheckPredicate, 93,                    // 1624:     check predicate 93
  OPC_CheckField, 6, 1, 1,                   // 1626:     check Inst[6] == 0x1
  OPC_Decode, 137, 28, 153, 4,               // 1630:     decode to VSMMLA using decoder 537
                                             // 1630:    }
  249, 3, 0,                                 // 1635:    case 0x1f9: {
  OPC_CheckPredicate, 93,                    // 1638:     check predicate 93
  OPC_CheckField, 6, 1, 1,                   // 1640:     check Inst[6] == 0x1
  OPC_Decode, 167, 31, 153, 4,               // 1644:     decode to VUSMMLA using decoder 537
                                             // 1644:    }
                                             // 1644:    } // switch Inst[31:23]
                                             // 1644:   }
                                             // 1644:   } // switch Inst[21:20]
                                             // 1644:  }
  1, 0,                                      // 1649:  case 0x1: {
  OPC_CheckPredicate, 93,                    // 1651:   check predicate 93
  OPC_CheckField, 23, 9, 248, 3,             // 1653:   check Inst[31:23] == 0x1f8
  OPC_CheckField, 20, 2, 2,                  // 1658:   check Inst[21:20] == 0x2
  OPC_CheckField, 6, 1, 1,                   // 1662:   check Inst[6] == 0x1
  OPC_Decode, 162, 31, 153, 4,               // 1666:   decode to VUMMLA using decoder 537
                                             // 1666:  }
                                             // 1666:  } // switch Inst[4]
                                             // 1666: }
  13, 0,                                     // 1671: case 0xd: {
  OPC_SwitchField, 23, 9,                    // 1673:  switch Inst[31:23] {
  248, 3, 85,                                // 1676:  case 0x1f8: {
  OPC_SwitchField, 4, 1,                     // 1679:   switch Inst[4] {
  0, 49,                                     // 1682:   case 0x0: {
  OPC_SwitchField, 6, 1,                     // 1684:    switch Inst[6] {
  0, 21,                                     // 1687:    case 0x0: {
  OPC_SwitchField, 20, 2,                    // 1689:     switch Inst[21:20] {
  0, 7,                                      // 1692:     case 0x0: {
  OPC_CheckPredicate, 40,                    // 1694:      check predicate 40
  OPC_Decode, 180, 6, 164, 4,                // 1696:      decode to BF16VDOTS_VDOTD using decoder 548
                                             // 1696:     }
  2, 0,                                      // 1701:     case 0x2: {
  OPC_CheckPredicate, 94,                    // 1703:      check predicate 94
  OPC_Decode, 177, 27, 164, 4,               // 1705:      decode to VSDOTD using decoder 548
                                             // 1705:     }
                                             // 1705:     } // switch Inst[21:20]
                                             // 1705:    }
  1, 0,                                      // 1710:    case 0x1: {
  OPC_SwitchField, 20, 2,                    // 1712:     switch Inst[21:20] {
  0, 7,                                      // 1715:     case 0x0: {
  OPC_CheckPredicate, 40,                    // 1717:      check predicate 40
  OPC_Decode, 181, 6, 153, 4,                // 1719:      decode to BF16VDOTS_VDOTQ using decoder 537
                                             // 1719:     }
  2, 0,                                      // 1724:     case 0x2: {
  OPC_CheckPredicate, 94,                    // 1726:      check predicate 94
  OPC_Decode, 179, 27, 153, 4,               // 1728:      decode to VSDOTQ using decoder 537
                                             // 1728:     }
                                             // 1728:     } // switch Inst[21:20]
                                             // 1728:    }
                                             // 1728:    } // switch Inst[6]
                                             // 1728:   }
  1, 0,                                      // 1733:   case 0x1: {
  OPC_SwitchField, 6, 1,                     // 1735:    switch Inst[6] {
  0, 11,                                     // 1738:    case 0x0: {
  OPC_CheckPredicate, 94,                    // 1740:     check predicate 94
  OPC_CheckField, 20, 2, 2,                  // 1742:     check Inst[21:20] == 0x2
  OPC_Decode, 149, 31, 164, 4,               // 1746:     decode to VUDOTD using decoder 548
                                             // 1746:    }
  1, 0,                                      // 1751:    case 0x1: {
  OPC_CheckPredicate, 94,                    // 1753:     check predicate 94
  OPC_CheckField, 20, 2, 2,                  // 1755:     check Inst[21:20] == 0x2
  OPC_Decode, 151, 31, 153, 4,               // 1759:     decode to VUDOTQ using decoder 537
                                             // 1759:    }
                                             // 1759:    } // switch Inst[6]
                                             // 1759:   }
                                             // 1759:   } // switch Inst[4]
                                             // 1759:  }
  249, 3, 37,                                // 1764:  case 0x1f9: {
  OPC_SwitchField, 6, 1,                     // 1767:   switch Inst[6] {
  0, 15,                                     // 1770:   case 0x0: {
  OPC_CheckPredicate, 93,                    // 1772:    check predicate 93
  OPC_CheckField, 20, 2, 2,                  // 1774:    check Inst[21:20] == 0x2
  OPC_CheckField, 4, 1, 0,                   // 1778:    check Inst[4] == 0x0
  OPC_Decode, 163, 31, 164, 4,               // 1782:    decode to VUSDOTD using decoder 548
                                             // 1782:   }
  1, 0,                                      // 1787:   case 0x1: {
  OPC_CheckPredicate, 93,                    // 1789:    check predicate 93
  OPC_CheckField, 20, 2, 2,                  // 1791:    check Inst[21:20] == 0x2
  OPC_CheckField, 4, 1, 0,                   // 1795:    check Inst[4] == 0x0
  OPC_Decode, 165, 31, 153, 4,               // 1799:    decode to VUSDOTQ using decoder 537
                                             // 1799:   }
                                             // 1799:   } // switch Inst[6]
                                             // 1799:  }
  252, 3, 85,                                // 1804:  case 0x1fc: {
  OPC_SwitchField, 4, 1,                     // 1807:   switch Inst[4] {
  0, 49,                                     // 1810:   case 0x0: {
  OPC_SwitchField, 6, 1,                     // 1812:    switch Inst[6] {
  0, 21,                                     // 1815:    case 0x0: {
  OPC_SwitchField, 20, 2,                    // 1817:     switch Inst[21:20] {
  0, 7,                                      // 1820:     case 0x0: {
  OPC_CheckPredicate, 40,                    // 1822:      check predicate 40
  OPC_Decode, 178, 6, 165, 4,                // 1824:      decode to BF16VDOTI_VDOTD using decoder 549
                                             // 1824:     }
  2, 0,                                      // 1829:     case 0x2: {
  OPC_CheckPredicate, 94,                    // 1831:      check predicate 94
  OPC_Decode, 178, 27, 165, 4,               // 1833:      decode to VSDOTDI using decoder 549
                                             // 1833:     }
                                             // 1833:     } // switch Inst[21:20]
                                             // 1833:    }
  1, 0,                                      // 1838:    case 0x1: {
  OPC_SwitchField, 20, 2,                    // 1840:     switch Inst[21:20] {
  0, 7,                                      // 1843:     case 0x0: {
  OPC_CheckPredicate, 40,                    // 1845:      check predicate 40
  OPC_Decode, 179, 6, 166, 4,                // 1847:      decode to BF16VDOTI_VDOTQ using decoder 550
                                             // 1847:     }
  2, 0,                                      // 1852:     case 0x2: {
  OPC_CheckPredicate, 94,                    // 1854:      check predicate 94
  OPC_Decode, 180, 27, 166, 4,               // 1856:      decode to VSDOTQI using decoder 550
                                             // 1856:     }
                                             // 1856:     } // switch Inst[21:20]
                                             // 1856:    }
                                             // 1856:    } // switch Inst[6]
                                             // 1856:   }
  1, 0,                                      // 1861:   case 0x1: {
  OPC_SwitchField, 6, 1,                     // 1863:    switch Inst[6] {
  0, 11,                                     // 1866:    case 0x0: {
  OPC_CheckPredicate, 94,                    // 1868:     check predicate 94
  OPC_CheckField, 20, 2, 2,                  // 1870:     check Inst[21:20] == 0x2
  OPC_Decode, 150, 31, 165, 4,               // 1874:     decode to VUDOTDI using decoder 549
                                             // 1874:    }
  1, 0,                                      // 1879:    case 0x1: {
  OPC_CheckPredicate, 94,                    // 1881:     check predicate 94
  OPC_CheckField, 20, 2, 2,                  // 1883:     check Inst[21:20] == 0x2
  OPC_Decode, 152, 31, 166, 4,               // 1887:     decode to VUDOTQI using decoder 550
                                             // 1887:    }
                                             // 1887:    } // switch Inst[6]
                                             // 1887:   }
                                             // 1887:   } // switch Inst[4]
                                             // 1887:  }
  253, 3, 0,                                 // 1892:  case 0x1fd: {
  OPC_SwitchField, 4, 1,                     // 1895:   switch Inst[4] {
  0, 29,                                     // 1898:   case 0x0: {
  OPC_SwitchField, 6, 1,                     // 1900:    switch Inst[6] {
  0, 11,                                     // 1903:    case 0x0: {
  OPC_CheckPredicate, 93,                    // 1905:     check predicate 93
  OPC_CheckField, 20, 2, 0,                  // 1907:     check Inst[21:20] == 0x0
  OPC_Decode, 164, 31, 165, 4,               // 1911:     decode to VUSDOTDI using decoder 549
                                             // 1911:    }
  1, 0,                                      // 1916:    case 0x1: {
  OPC_CheckPredicate, 93,                    // 1918:     check predicate 93
  OPC_CheckField, 20, 2, 0,                  // 1920:     check Inst[21:20] == 0x0
  OPC_Decode, 166, 31, 166, 4,               // 1924:     decode to VUSDOTQI using decoder 550
                                             // 1924:    }
                                             // 1924:    } // switch Inst[6]
                                             // 1924:   }
  1, 0,                                      // 1929:   case 0x1: {
  OPC_SwitchField, 6, 1,                     // 1931:    switch Inst[6] {
  0, 11,                                     // 1934:    case 0x0: {
  OPC_CheckPredicate, 93,                    // 1936:     check predicate 93
  OPC_CheckField, 20, 2, 0,                  // 1938:     check Inst[21:20] == 0x0
  OPC_Decode, 225, 30, 165, 4,               // 1942:     decode to VSUDOTDI using decoder 549
                                             // 1942:    }
  1, 0,                                      // 1947:    case 0x1: {
  OPC_CheckPredicate, 93,                    // 1949:     check predicate 93
  OPC_CheckField, 20, 2, 0,                  // 1951:     check Inst[21:20] == 0x0
  OPC_Decode, 226, 30, 166, 4,               // 1955:     decode to VSUDOTQI using decoder 550
                                             // 1955:    }
                                             // 1955:    } // switch Inst[6]
                                             // 1955:   }
                                             // 1955:   } // switch Inst[4]
                                             // 1955:  }
                                             // 1955:  } // switch Inst[31:23]
                                             // 1955: }
                                             // 1955: } // switch Inst[11:8]
};
static const uint8_t DecoderTablev8Crypto32[335] = {
  OPC_SwitchField, 20, 2,                    //   0: switch Inst[21:20] {
  0, 47,                                     //   3: case 0x0: {
  OPC_SwitchField, 23, 9,                    //   5:  switch Inst[31:23] {
  228, 3, 19,                                //   8:  case 0x1e4: {
  OPC_CheckPredicate, 95,                    //  11:   check predicate 95
  OPC_CheckField, 8, 4, 12,                  //  13:   check Inst[11:8] == 0xc
  OPC_CheckField, 6, 1, 1,                   //  17:   check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  21:   check Inst[4] == 0x0
  OPC_Decode, 254, 14, 153, 4,               //  25:   decode to SHA1C using decoder 537
                                             //  25:  }
  230, 3, 0,                                 //  30:  case 0x1e6: {
  OPC_CheckPredicate, 95,                    //  33:   check predicate 95
  OPC_CheckField, 8, 4, 12,                  //  35:   check Inst[11:8] == 0xc
  OPC_CheckField, 6, 1, 1,                   //  39:   check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  43:   check Inst[4] == 0x0
  OPC_Decode, 132, 15, 153, 4,               //  47:   decode to SHA256H using decoder 537
                                             //  47:  }
                                             //  47:  } // switch Inst[31:23]
                                             //  47: }
  1, 47,                                     //  52: case 0x1: {
  OPC_SwitchField, 23, 9,                    //  54:  switch Inst[31:23] {
  228, 3, 19,                                //  57:  case 0x1e4: {
  OPC_CheckPredicate, 95,                    //  60:   check predicate 95
  OPC_CheckField, 8, 4, 12,                  //  62:   check Inst[11:8] == 0xc
  OPC_CheckField, 6, 1, 1,                   //  66:   check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  70:   check Inst[4] == 0x0
  OPC_Decode, 129, 15, 153, 4,               //  74:   decode to SHA1P using decoder 537
                                             //  74:  }
  230, 3, 0,                                 //  79:  case 0x1e6: {
  OPC_CheckPredicate, 95,                    //  82:   check predicate 95
  OPC_CheckField, 8, 4, 12,                  //  84:   check Inst[11:8] == 0xc
  OPC_CheckField, 6, 1, 1,                   //  88:   check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   //  92:   check Inst[4] == 0x0
  OPC_Decode, 133, 15, 153, 4,               //  96:   decode to SHA256H2 using decoder 537
                                             //  96:  }
                                             //  96:  } // switch Inst[31:23]
                                             //  96: }
  2, 47,                                     // 101: case 0x2: {
  OPC_SwitchField, 23, 9,                    // 103:  switch Inst[31:23] {
  228, 3, 19,                                // 106:  case 0x1e4: {
  OPC_CheckPredicate, 95,                    // 109:   check predicate 95
  OPC_CheckField, 8, 4, 12,                  // 111:   check Inst[11:8] == 0xc
  OPC_CheckField, 6, 1, 1,                   // 115:   check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 119:   check Inst[4] == 0x0
  OPC_Decode, 128, 15, 153, 4,               // 123:   decode to SHA1M using decoder 537
                                             // 123:  }
  230, 3, 0,                                 // 128:  case 0x1e6: {
  OPC_CheckPredicate, 95,                    // 131:   check predicate 95
  OPC_CheckField, 8, 4, 12,                  // 133:   check Inst[11:8] == 0xc
  OPC_CheckField, 6, 1, 1,                   // 137:   check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 141:   check Inst[4] == 0x0
  OPC_Decode, 135, 15, 153, 4,               // 145:   decode to SHA256SU1 using decoder 537
                                             // 145:  }
                                             // 145:  } // switch Inst[31:23]
                                             // 145: }
  3, 0,                                      // 150: case 0x3: {
  OPC_SwitchField, 8, 4,                     // 152:  switch Inst[11:8] {
  2, 24,                                     // 155:  case 0x2: {
  OPC_CheckPredicate, 95,                    // 157:   check predicate 95
  OPC_CheckField, 23, 9, 231, 3,             // 159:   check Inst[31:23] == 0x1e7
  OPC_CheckField, 16, 4, 9,                  // 164:   check Inst[19:16] == 0x9
  OPC_CheckField, 6, 2, 3,                   // 168:   check Inst[7:6] == 0x3
  OPC_CheckField, 4, 1, 0,                   // 172:   check Inst[4] == 0x0
  OPC_Decode, 255, 14, 167, 4,               // 176:   decode to SHA1H using decoder 551
                                             // 176:  }
  3, 129, 1,                                 // 181:  case 0x3: {
  OPC_SwitchField, 6, 2,                     // 184:   switch Inst[7:6] {
  0, 20,                                     // 187:   case 0x0: {
  OPC_CheckPredicate, 38,                    // 189:    check predicate 38
  OPC_CheckField, 23, 9, 231, 3,             // 191:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 16, 4, 0,                  // 196:    check Inst[19:16] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 200:    check Inst[4] == 0x0
  OPC_Decode, 171, 6, 168, 4,                // 204:    decode to AESE using decoder 552
                                             // 204:   }
  1, 20,                                     // 209:   case 0x1: {
  OPC_CheckPredicate, 38,                    // 211:    check predicate 38
  OPC_CheckField, 23, 9, 231, 3,             // 213:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 16, 4, 0,                  // 218:    check Inst[19:16] == 0x0
  OPC_CheckField, 4, 1, 0,                   // 222:    check Inst[4] == 0x0
  OPC_Decode, 170, 6, 168, 4,                // 226:    decode to AESD using decoder 552
                                             // 226:   }
  2, 39,                                     // 231:   case 0x2: {
  OPC_SwitchField, 16, 4,                    // 233:    switch Inst[19:16] {
  0, 16,                                     // 236:    case 0x0: {
  OPC_CheckPredicate, 38,                    // 238:     check predicate 38
  OPC_CheckField, 23, 9, 231, 3,             // 240:     check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 245:     check Inst[4] == 0x0
  OPC_Decode, 173, 6, 167, 4,                // 249:     decode to AESMC using decoder 551
                                             // 249:    }
  10, 0,                                     // 254:    case 0xa: {
  OPC_CheckPredicate, 95,                    // 256:     check predicate 95
  OPC_CheckField, 23, 9, 231, 3,             // 258:     check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 263:     check Inst[4] == 0x0
  OPC_Decode, 131, 15, 168, 4,               // 267:     decode to SHA1SU1 using decoder 552
                                             // 267:    }
                                             // 267:    } // switch Inst[19:16]
                                             // 267:   }
  3, 0,                                      // 272:   case 0x3: {
  OPC_SwitchField, 16, 4,                    // 274:    switch Inst[19:16] {
  0, 16,                                     // 277:    case 0x0: {
  OPC_CheckPredicate, 38,                    // 279:     check predicate 38
  OPC_CheckField, 23, 9, 231, 3,             // 281:     check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 286:     check Inst[4] == 0x0
  OPC_Decode, 172, 6, 167, 4,                // 290:     decode to AESIMC using decoder 551
                                             // 290:    }
  10, 0,                                     // 295:    case 0xa: {
  OPC_CheckPredicate, 95,                    // 297:     check predicate 95
  OPC_CheckField, 23, 9, 231, 3,             // 299:     check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 304:     check Inst[4] == 0x0
  OPC_Decode, 134, 15, 168, 4,               // 308:     decode to SHA256SU0 using decoder 552
                                             // 308:    }
                                             // 308:    } // switch Inst[19:16]
                                             // 308:   }
                                             // 308:   } // switch Inst[7:6]
                                             // 308:  }
  12, 0,                                     // 313:  case 0xc: {
  OPC_CheckPredicate, 95,                    // 315:   check predicate 95
  OPC_CheckField, 23, 9, 228, 3,             // 317:   check Inst[31:23] == 0x1e4
  OPC_CheckField, 6, 1, 1,                   // 322:   check Inst[6] == 0x1
  OPC_CheckField, 4, 1, 0,                   // 326:   check Inst[4] == 0x0
  OPC_Decode, 130, 15, 153, 4,               // 330:   decode to SHA1SU0 using decoder 537
                                             // 330:  }
                                             // 330:  } // switch Inst[11:8]
                                             // 330: }
                                             // 330: } // switch Inst[21:20]
};
static const uint8_t DecoderTablev8NEON32[1366] = {
  OPC_SwitchField, 8, 4,                     //    0: switch Inst[11:8] {
  0, 167, 1,                                 //    3: case 0x0: {
  OPC_SwitchField, 6, 2,                     //    6:  switch Inst[7:6] {
  0, 39,                                     //    9:  case 0x0: {
  OPC_SwitchField, 16, 6,                    //   11:   switch Inst[21:16] {
  55, 16,                                    //   14:   case 0x37: {
  OPC_CheckPredicate, 96,                    //   16:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //   18:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //   23:    check Inst[4] == 0x0
  OPC_Decode, 166, 18, 162, 4,               //   27:    decode to VCVTANSDh using decoder 546
                                             //   27:   }
  59, 0,                                     //   32:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //   34:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //   36:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //   41:    check Inst[4] == 0x0
  OPC_Decode, 165, 18, 162, 4,               //   45:    decode to VCVTANSDf using decoder 546
                                             //   45:   }
                                             //   45:   } // switch Inst[21:16]
                                             //   45:  }
  1, 39,                                     //   50:  case 0x1: {
  OPC_SwitchField, 16, 6,                    //   52:   switch Inst[21:16] {
  55, 16,                                    //   55:   case 0x37: {
  OPC_CheckPredicate, 96,                    //   57:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //   59:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //   64:    check Inst[4] == 0x0
  OPC_Decode, 168, 18, 167, 4,               //   68:    decode to VCVTANSQh using decoder 551
                                             //   68:   }
  59, 0,                                     //   73:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //   75:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //   77:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //   82:    check Inst[4] == 0x0
  OPC_Decode, 167, 18, 167, 4,               //   86:    decode to VCVTANSQf using decoder 551
                                             //   86:   }
                                             //   86:   } // switch Inst[21:16]
                                             //   86:  }
  2, 39,                                     //   91:  case 0x2: {
  OPC_SwitchField, 16, 6,                    //   93:   switch Inst[21:16] {
  55, 16,                                    //   96:   case 0x37: {
  OPC_CheckPredicate, 96,                    //   98:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  100:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  105:    check Inst[4] == 0x0
  OPC_Decode, 170, 18, 162, 4,               //  109:    decode to VCVTANUDh using decoder 546
                                             //  109:   }
  59, 0,                                     //  114:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  116:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  118:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  123:    check Inst[4] == 0x0
  OPC_Decode, 169, 18, 162, 4,               //  127:    decode to VCVTANUDf using decoder 546
                                             //  127:   }
                                             //  127:   } // switch Inst[21:16]
                                             //  127:  }
  3, 0,                                      //  132:  case 0x3: {
  OPC_SwitchField, 16, 6,                    //  134:   switch Inst[21:16] {
  55, 16,                                    //  137:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  139:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  141:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  146:    check Inst[4] == 0x0
  OPC_Decode, 172, 18, 167, 4,               //  150:    decode to VCVTANUQh using decoder 551
                                             //  150:   }
  59, 0,                                     //  155:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  157:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  159:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  164:    check Inst[4] == 0x0
  OPC_Decode, 171, 18, 167, 4,               //  168:    decode to VCVTANUQf using decoder 551
                                             //  168:   }
                                             //  168:   } // switch Inst[21:16]
                                             //  168:  }
                                             //  168:  } // switch Inst[7:6]
                                             //  168: }
  1, 167, 1,                                 //  173: case 0x1: {
  OPC_SwitchField, 6, 2,                     //  176:  switch Inst[7:6] {
  0, 39,                                     //  179:  case 0x0: {
  OPC_SwitchField, 16, 6,                    //  181:   switch Inst[21:16] {
  55, 16,                                    //  184:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  186:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  188:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  193:    check Inst[4] == 0x0
  OPC_Decode, 199, 18, 162, 4,               //  197:    decode to VCVTNNSDh using decoder 546
                                             //  197:   }
  59, 0,                                     //  202:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  204:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  206:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  211:    check Inst[4] == 0x0
  OPC_Decode, 198, 18, 162, 4,               //  215:    decode to VCVTNNSDf using decoder 546
                                             //  215:   }
                                             //  215:   } // switch Inst[21:16]
                                             //  215:  }
  1, 39,                                     //  220:  case 0x1: {
  OPC_SwitchField, 16, 6,                    //  222:   switch Inst[21:16] {
  55, 16,                                    //  225:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  227:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  229:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  234:    check Inst[4] == 0x0
  OPC_Decode, 201, 18, 167, 4,               //  238:    decode to VCVTNNSQh using decoder 551
                                             //  238:   }
  59, 0,                                     //  243:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  245:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  247:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  252:    check Inst[4] == 0x0
  OPC_Decode, 200, 18, 167, 4,               //  256:    decode to VCVTNNSQf using decoder 551
                                             //  256:   }
                                             //  256:   } // switch Inst[21:16]
                                             //  256:  }
  2, 39,                                     //  261:  case 0x2: {
  OPC_SwitchField, 16, 6,                    //  263:   switch Inst[21:16] {
  55, 16,                                    //  266:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  268:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  270:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  275:    check Inst[4] == 0x0
  OPC_Decode, 203, 18, 162, 4,               //  279:    decode to VCVTNNUDh using decoder 546
                                             //  279:   }
  59, 0,                                     //  284:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  286:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  288:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  293:    check Inst[4] == 0x0
  OPC_Decode, 202, 18, 162, 4,               //  297:    decode to VCVTNNUDf using decoder 546
                                             //  297:   }
                                             //  297:   } // switch Inst[21:16]
                                             //  297:  }
  3, 0,                                      //  302:  case 0x3: {
  OPC_SwitchField, 16, 6,                    //  304:   switch Inst[21:16] {
  55, 16,                                    //  307:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  309:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  311:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  316:    check Inst[4] == 0x0
  OPC_Decode, 205, 18, 167, 4,               //  320:    decode to VCVTNNUQh using decoder 551
                                             //  320:   }
  59, 0,                                     //  325:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  327:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  329:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  334:    check Inst[4] == 0x0
  OPC_Decode, 204, 18, 167, 4,               //  338:    decode to VCVTNNUQf using decoder 551
                                             //  338:   }
                                             //  338:   } // switch Inst[21:16]
                                             //  338:  }
                                             //  338:  } // switch Inst[7:6]
                                             //  338: }
  2, 167, 1,                                 //  343: case 0x2: {
  OPC_SwitchField, 6, 2,                     //  346:  switch Inst[7:6] {
  0, 39,                                     //  349:  case 0x0: {
  OPC_SwitchField, 16, 6,                    //  351:   switch Inst[21:16] {
  55, 16,                                    //  354:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  356:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  358:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  363:    check Inst[4] == 0x0
  OPC_Decode, 213, 18, 162, 4,               //  367:    decode to VCVTPNSDh using decoder 546
                                             //  367:   }
  59, 0,                                     //  372:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  374:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  376:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  381:    check Inst[4] == 0x0
  OPC_Decode, 212, 18, 162, 4,               //  385:    decode to VCVTPNSDf using decoder 546
                                             //  385:   }
                                             //  385:   } // switch Inst[21:16]
                                             //  385:  }
  1, 39,                                     //  390:  case 0x1: {
  OPC_SwitchField, 16, 6,                    //  392:   switch Inst[21:16] {
  55, 16,                                    //  395:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  397:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  399:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  404:    check Inst[4] == 0x0
  OPC_Decode, 215, 18, 167, 4,               //  408:    decode to VCVTPNSQh using decoder 551
                                             //  408:   }
  59, 0,                                     //  413:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  415:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  417:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  422:    check Inst[4] == 0x0
  OPC_Decode, 214, 18, 167, 4,               //  426:    decode to VCVTPNSQf using decoder 551
                                             //  426:   }
                                             //  426:   } // switch Inst[21:16]
                                             //  426:  }
  2, 39,                                     //  431:  case 0x2: {
  OPC_SwitchField, 16, 6,                    //  433:   switch Inst[21:16] {
  55, 16,                                    //  436:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  438:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  440:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  445:    check Inst[4] == 0x0
  OPC_Decode, 217, 18, 162, 4,               //  449:    decode to VCVTPNUDh using decoder 546
                                             //  449:   }
  59, 0,                                     //  454:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  456:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  458:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  463:    check Inst[4] == 0x0
  OPC_Decode, 216, 18, 162, 4,               //  467:    decode to VCVTPNUDf using decoder 546
                                             //  467:   }
                                             //  467:   } // switch Inst[21:16]
                                             //  467:  }
  3, 0,                                      //  472:  case 0x3: {
  OPC_SwitchField, 16, 6,                    //  474:   switch Inst[21:16] {
  55, 16,                                    //  477:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  479:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  481:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  486:    check Inst[4] == 0x0
  OPC_Decode, 219, 18, 167, 4,               //  490:    decode to VCVTPNUQh using decoder 551
                                             //  490:   }
  59, 0,                                     //  495:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  497:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  499:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  504:    check Inst[4] == 0x0
  OPC_Decode, 218, 18, 167, 4,               //  508:    decode to VCVTPNUQf using decoder 551
                                             //  508:   }
                                             //  508:   } // switch Inst[21:16]
                                             //  508:  }
                                             //  508:  } // switch Inst[7:6]
                                             //  508: }
  3, 167, 1,                                 //  513: case 0x3: {
  OPC_SwitchField, 6, 2,                     //  516:  switch Inst[7:6] {
  0, 39,                                     //  519:  case 0x0: {
  OPC_SwitchField, 16, 6,                    //  521:   switch Inst[21:16] {
  55, 16,                                    //  524:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  526:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  528:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  533:    check Inst[4] == 0x0
  OPC_Decode, 185, 18, 162, 4,               //  537:    decode to VCVTMNSDh using decoder 546
                                             //  537:   }
  59, 0,                                     //  542:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  544:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  546:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  551:    check Inst[4] == 0x0
  OPC_Decode, 184, 18, 162, 4,               //  555:    decode to VCVTMNSDf using decoder 546
                                             //  555:   }
                                             //  555:   } // switch Inst[21:16]
                                             //  555:  }
  1, 39,                                     //  560:  case 0x1: {
  OPC_SwitchField, 16, 6,                    //  562:   switch Inst[21:16] {
  55, 16,                                    //  565:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  567:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  569:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  574:    check Inst[4] == 0x0
  OPC_Decode, 187, 18, 167, 4,               //  578:    decode to VCVTMNSQh using decoder 551
                                             //  578:   }
  59, 0,                                     //  583:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  585:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  587:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  592:    check Inst[4] == 0x0
  OPC_Decode, 186, 18, 167, 4,               //  596:    decode to VCVTMNSQf using decoder 551
                                             //  596:   }
                                             //  596:   } // switch Inst[21:16]
                                             //  596:  }
  2, 39,                                     //  601:  case 0x2: {
  OPC_SwitchField, 16, 6,                    //  603:   switch Inst[21:16] {
  55, 16,                                    //  606:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  608:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  610:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  615:    check Inst[4] == 0x0
  OPC_Decode, 189, 18, 162, 4,               //  619:    decode to VCVTMNUDh using decoder 546
                                             //  619:   }
  59, 0,                                     //  624:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  626:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  628:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  633:    check Inst[4] == 0x0
  OPC_Decode, 188, 18, 162, 4,               //  637:    decode to VCVTMNUDf using decoder 546
                                             //  637:   }
                                             //  637:   } // switch Inst[21:16]
                                             //  637:  }
  3, 0,                                      //  642:  case 0x3: {
  OPC_SwitchField, 16, 6,                    //  644:   switch Inst[21:16] {
  55, 16,                                    //  647:   case 0x37: {
  OPC_CheckPredicate, 96,                    //  649:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  651:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  656:    check Inst[4] == 0x0
  OPC_Decode, 191, 18, 167, 4,               //  660:    decode to VCVTMNUQh using decoder 551
                                             //  660:   }
  59, 0,                                     //  665:   case 0x3b: {
  OPC_CheckPredicate, 97,                    //  667:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  669:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  674:    check Inst[4] == 0x0
  OPC_Decode, 190, 18, 167, 4,               //  678:    decode to VCVTMNUQf using decoder 551
                                             //  678:   }
                                             //  678:   } // switch Inst[21:16]
                                             //  678:  }
                                             //  678:  } // switch Inst[7:6]
                                             //  678: }
  4, 167, 1,                                 //  683: case 0x4: {
  OPC_SwitchField, 6, 2,                     //  686:  switch Inst[7:6] {
  0, 39,                                     //  689:  case 0x0: {
  OPC_SwitchField, 16, 6,                    //  691:   switch Inst[21:16] {
  54, 16,                                    //  694:   case 0x36: {
  OPC_CheckPredicate, 96,                    //  696:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  698:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  703:    check Inst[4] == 0x0
  OPC_Decode, 211, 26, 162, 4,               //  707:    decode to VRINTNNDh using decoder 546
                                             //  707:   }
  58, 0,                                     //  712:   case 0x3a: {
  OPC_CheckPredicate, 97,                    //  714:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  716:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  721:    check Inst[4] == 0x0
  OPC_Decode, 210, 26, 162, 4,               //  725:    decode to VRINTNNDf using decoder 546
                                             //  725:   }
                                             //  725:   } // switch Inst[21:16]
                                             //  725:  }
  1, 39,                                     //  730:  case 0x1: {
  OPC_SwitchField, 16, 6,                    //  732:   switch Inst[21:16] {
  54, 16,                                    //  735:   case 0x36: {
  OPC_CheckPredicate, 96,                    //  737:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  739:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  744:    check Inst[4] == 0x0
  OPC_Decode, 213, 26, 167, 4,               //  748:    decode to VRINTNNQh using decoder 551
                                             //  748:   }
  58, 0,                                     //  753:   case 0x3a: {
  OPC_CheckPredicate, 97,                    //  755:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  757:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  762:    check Inst[4] == 0x0
  OPC_Decode, 212, 26, 167, 4,               //  766:    decode to VRINTNNQf using decoder 551
                                             //  766:   }
                                             //  766:   } // switch Inst[21:16]
                                             //  766:  }
  2, 39,                                     //  771:  case 0x2: {
  OPC_SwitchField, 16, 6,                    //  773:   switch Inst[21:16] {
  54, 16,                                    //  776:   case 0x36: {
  OPC_CheckPredicate, 96,                    //  778:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  780:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  785:    check Inst[4] == 0x0
  OPC_Decode, 228, 26, 162, 4,               //  789:    decode to VRINTXNDh using decoder 546
                                             //  789:   }
  58, 0,                                     //  794:   case 0x3a: {
  OPC_CheckPredicate, 97,                    //  796:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  798:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  803:    check Inst[4] == 0x0
  OPC_Decode, 227, 26, 162, 4,               //  807:    decode to VRINTXNDf using decoder 546
                                             //  807:   }
                                             //  807:   } // switch Inst[21:16]
                                             //  807:  }
  3, 0,                                      //  812:  case 0x3: {
  OPC_SwitchField, 16, 6,                    //  814:   switch Inst[21:16] {
  54, 16,                                    //  817:   case 0x36: {
  OPC_CheckPredicate, 96,                    //  819:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  821:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  826:    check Inst[4] == 0x0
  OPC_Decode, 230, 26, 167, 4,               //  830:    decode to VRINTXNQh using decoder 551
                                             //  830:   }
  58, 0,                                     //  835:   case 0x3a: {
  OPC_CheckPredicate, 97,                    //  837:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  839:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  844:    check Inst[4] == 0x0
  OPC_Decode, 229, 26, 167, 4,               //  848:    decode to VRINTXNQf using decoder 551
                                             //  848:   }
                                             //  848:   } // switch Inst[21:16]
                                             //  848:  }
                                             //  848:  } // switch Inst[7:6]
                                             //  848: }
  5, 167, 1,                                 //  853: case 0x5: {
  OPC_SwitchField, 6, 2,                     //  856:  switch Inst[7:6] {
  0, 39,                                     //  859:  case 0x0: {
  OPC_SwitchField, 16, 6,                    //  861:   switch Inst[21:16] {
  54, 16,                                    //  864:   case 0x36: {
  OPC_CheckPredicate, 96,                    //  866:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  868:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  873:    check Inst[4] == 0x0
  OPC_Decode, 197, 26, 162, 4,               //  877:    decode to VRINTANDh using decoder 546
                                             //  877:   }
  58, 0,                                     //  882:   case 0x3a: {
  OPC_CheckPredicate, 97,                    //  884:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  886:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  891:    check Inst[4] == 0x0
  OPC_Decode, 196, 26, 162, 4,               //  895:    decode to VRINTANDf using decoder 546
                                             //  895:   }
                                             //  895:   } // switch Inst[21:16]
                                             //  895:  }
  1, 39,                                     //  900:  case 0x1: {
  OPC_SwitchField, 16, 6,                    //  902:   switch Inst[21:16] {
  54, 16,                                    //  905:   case 0x36: {
  OPC_CheckPredicate, 96,                    //  907:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  909:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  914:    check Inst[4] == 0x0
  OPC_Decode, 199, 26, 167, 4,               //  918:    decode to VRINTANQh using decoder 551
                                             //  918:   }
  58, 0,                                     //  923:   case 0x3a: {
  OPC_CheckPredicate, 97,                    //  925:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  927:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  932:    check Inst[4] == 0x0
  OPC_Decode, 198, 26, 167, 4,               //  936:    decode to VRINTANQf using decoder 551
                                             //  936:   }
                                             //  936:   } // switch Inst[21:16]
                                             //  936:  }
  2, 39,                                     //  941:  case 0x2: {
  OPC_SwitchField, 16, 6,                    //  943:   switch Inst[21:16] {
  54, 16,                                    //  946:   case 0x36: {
  OPC_CheckPredicate, 96,                    //  948:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  950:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  955:    check Inst[4] == 0x0
  OPC_Decode, 235, 26, 162, 4,               //  959:    decode to VRINTZNDh using decoder 546
                                             //  959:   }
  58, 0,                                     //  964:   case 0x3a: {
  OPC_CheckPredicate, 97,                    //  966:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             //  968:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  973:    check Inst[4] == 0x0
  OPC_Decode, 234, 26, 162, 4,               //  977:    decode to VRINTZNDf using decoder 546
                                             //  977:   }
                                             //  977:   } // switch Inst[21:16]
                                             //  977:  }
  3, 0,                                      //  982:  case 0x3: {
  OPC_SwitchField, 16, 6,                    //  984:   switch Inst[21:16] {
  54, 16,                                    //  987:   case 0x36: {
  OPC_CheckPredicate, 96,                    //  989:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             //  991:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   //  996:    check Inst[4] == 0x0
  OPC_Decode, 237, 26, 167, 4,               // 1000:    decode to VRINTZNQh using decoder 551
                                             // 1000:   }
  58, 0,                                     // 1005:   case 0x3a: {
  OPC_CheckPredicate, 97,                    // 1007:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             // 1009:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 1014:    check Inst[4] == 0x0
  OPC_Decode, 236, 26, 167, 4,               // 1018:    decode to VRINTZNQf using decoder 551
                                             // 1018:   }
                                             // 1018:   } // switch Inst[21:16]
                                             // 1018:  }
                                             // 1018:  } // switch Inst[7:6]
                                             // 1018: }
  6, 85,                                     // 1023: case 0x6: {
  OPC_SwitchField, 6, 2,                     // 1025:  switch Inst[7:6] {
  2, 39,                                     // 1028:  case 0x2: {
  OPC_SwitchField, 16, 6,                    // 1030:   switch Inst[21:16] {
  54, 16,                                    // 1033:   case 0x36: {
  OPC_CheckPredicate, 96,                    // 1035:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             // 1037:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 1042:    check Inst[4] == 0x0
  OPC_Decode, 204, 26, 162, 4,               // 1046:    decode to VRINTMNDh using decoder 546
                                             // 1046:   }
  58, 0,                                     // 1051:   case 0x3a: {
  OPC_CheckPredicate, 97,                    // 1053:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             // 1055:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 1060:    check Inst[4] == 0x0
  OPC_Decode, 203, 26, 162, 4,               // 1064:    decode to VRINTMNDf using decoder 546
                                             // 1064:   }
                                             // 1064:   } // switch Inst[21:16]
                                             // 1064:  }
  3, 0,                                      // 1069:  case 0x3: {
  OPC_SwitchField, 16, 6,                    // 1071:   switch Inst[21:16] {
  54, 16,                                    // 1074:   case 0x36: {
  OPC_CheckPredicate, 96,                    // 1076:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             // 1078:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 1083:    check Inst[4] == 0x0
  OPC_Decode, 206, 26, 167, 4,               // 1087:    decode to VRINTMNQh using decoder 551
                                             // 1087:   }
  58, 0,                                     // 1092:   case 0x3a: {
  OPC_CheckPredicate, 97,                    // 1094:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             // 1096:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 1101:    check Inst[4] == 0x0
  OPC_Decode, 205, 26, 167, 4,               // 1105:    decode to VRINTMNQf using decoder 551
                                             // 1105:   }
                                             // 1105:   } // switch Inst[21:16]
                                             // 1105:  }
                                             // 1105:  } // switch Inst[7:6]
                                             // 1105: }
  7, 85,                                     // 1110: case 0x7: {
  OPC_SwitchField, 6, 2,                     // 1112:  switch Inst[7:6] {
  2, 39,                                     // 1115:  case 0x2: {
  OPC_SwitchField, 16, 6,                    // 1117:   switch Inst[21:16] {
  54, 16,                                    // 1120:   case 0x36: {
  OPC_CheckPredicate, 96,                    // 1122:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             // 1124:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 1129:    check Inst[4] == 0x0
  OPC_Decode, 218, 26, 162, 4,               // 1133:    decode to VRINTPNDh using decoder 546
                                             // 1133:   }
  58, 0,                                     // 1138:   case 0x3a: {
  OPC_CheckPredicate, 97,                    // 1140:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             // 1142:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 1147:    check Inst[4] == 0x0
  OPC_Decode, 217, 26, 162, 4,               // 1151:    decode to VRINTPNDf using decoder 546
                                             // 1151:   }
                                             // 1151:   } // switch Inst[21:16]
                                             // 1151:  }
  3, 0,                                      // 1156:  case 0x3: {
  OPC_SwitchField, 16, 6,                    // 1158:   switch Inst[21:16] {
  54, 16,                                    // 1161:   case 0x36: {
  OPC_CheckPredicate, 96,                    // 1163:    check predicate 96
  OPC_CheckField, 23, 9, 231, 3,             // 1165:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 1170:    check Inst[4] == 0x0
  OPC_Decode, 220, 26, 167, 4,               // 1174:    decode to VRINTPNQh using decoder 551
                                             // 1174:   }
  58, 0,                                     // 1179:   case 0x3a: {
  OPC_CheckPredicate, 97,                    // 1181:    check predicate 97
  OPC_CheckField, 23, 9, 231, 3,             // 1183:    check Inst[31:23] == 0x1e7
  OPC_CheckField, 4, 1, 0,                   // 1188:    check Inst[4] == 0x0
  OPC_Decode, 219, 26, 167, 4,               // 1192:    decode to VRINTPNQf using decoder 551
                                             // 1192:   }
                                             // 1192:   } // switch Inst[21:16]
                                             // 1192:  }
                                             // 1192:  } // switch Inst[7:6]
                                             // 1192: }
  15, 0,                                     // 1197: case 0xf: {
  OPC_SwitchField, 20, 2,                    // 1199:  switch Inst[21:20] {
  0, 39,                                     // 1202:  case 0x0: {
  OPC_SwitchField, 6, 1,                     // 1204:   switch Inst[6] {
  0, 16,                                     // 1207:   case 0x0: {
  OPC_CheckPredicate, 98,                    // 1209:    check predicate 98
  OPC_CheckField, 23, 9, 230, 3,             // 1211:    check Inst[31:23] == 0x1e6
  OPC_CheckField, 4, 1, 1,                   // 1216:    check Inst[4] == 0x1
  OPC_Decode, 191, 14, 161, 4,               // 1220:    decode to NEON_VMAXNMNDf using decoder 545
                                             // 1220:   }
  1, 0,                                      // 1225:   case 0x1: {
  OPC_CheckPredicate, 98,                    // 1227:    check predicate 98
  OPC_CheckField, 23, 9, 230, 3,             // 1229:    check Inst[31:23] == 0x1e6
  OPC_CheckField, 4, 1, 1,                   // 1234:    check Inst[4] == 0x1
  OPC_Decode, 193, 14, 169, 4,               // 1238:    decode to NEON_VMAXNMNQf using decoder 553
                                             // 1238:   }
                                             // 1238:   } // switch Inst[6]
                                             // 1238:  }
  1, 39,                                     // 1243:  case 0x1: {
  OPC_SwitchField, 6, 1,                     // 1245:   switch Inst[6] {
  0, 16,                                     // 1248:   case 0x0: {
  OPC_CheckPredicate, 99,                    // 1250:    check predicate 99
  OPC_CheckField, 23, 9, 230, 3,             // 1252:    check Inst[31:23] == 0x1e6
  OPC_CheckField, 4, 1, 1,                   // 1257:    check Inst[4] == 0x1
  OPC_Decode, 192, 14, 161, 4,               // 1261:    decode to NEON_VMAXNMNDh using decoder 545
                                             // 1261:   }
  1, 0,                                      // 1266:   case 0x1: {
  OPC_CheckPredicate, 99,                    // 1268:    check predicate 99
  OPC_CheckField, 23, 9, 230, 3,             // 1270:    check Inst[31:23] == 0x1e6
  OPC_CheckField, 4, 1, 1,                   // 1275:    check Inst[4] == 0x1
  OPC_Decode, 194, 14, 169, 4,               // 1279:    decode to NEON_VMAXNMNQh using decoder 553
                                             // 1279:   }
                                             // 1279:   } // switch Inst[6]
                                             // 1279:  }
  2, 39,                                     // 1284:  case 0x2: {
  OPC_SwitchField, 6, 1,                     // 1286:   switch Inst[6] {
  0, 16,                                     // 1289:   case 0x0: {
  OPC_CheckPredicate, 98,                    // 1291:    check predicate 98
  OPC_CheckField, 23, 9, 230, 3,             // 1293:    check Inst[31:23] == 0x1e6
  OPC_CheckField, 4, 1, 1,                   // 1298:    check Inst[4] == 0x1
  OPC_Decode, 195, 14, 161, 4,               // 1302:    decode to NEON_VMINNMNDf using decoder 545
                                             // 1302:   }
  1, 0,                                      // 1307:   case 0x1: {
  OPC_CheckPredicate, 98,                    // 1309:    check predicate 98
  OPC_CheckField, 23, 9, 230, 3,             // 1311:    check Inst[31:23] == 0x1e6
  OPC_CheckField, 4, 1, 1,                   // 1316:    check Inst[4] == 0x1
  OPC_Decode, 197, 14, 169, 4,               // 1320:    decode to NEON_VMINNMNQf using decoder 553
                                             // 1320:   }
                                             // 1320:   } // switch Inst[6]
                                             // 1320:  }
  3, 0,                                      // 1325:  case 0x3: {
  OPC_SwitchField, 6, 1,                     // 1327:   switch Inst[6] {
  0, 16,                                     // 1330:   case 0x0: {
  OPC_CheckPredicate, 99,                    // 1332:    check predicate 99
  OPC_CheckField, 23, 9, 230, 3,             // 1334:    check Inst[31:23] == 0x1e6
  OPC_CheckField, 4, 1, 1,                   // 1339:    check Inst[4] == 0x1
  OPC_Decode, 196, 14, 161, 4,               // 1343:    decode to NEON_VMINNMNDh using decoder 545
                                             // 1343:   }
  1, 0,                                      // 1348:   case 0x1: {
  OPC_CheckPredicate, 99,                    // 1350:    check predicate 99
  OPC_CheckField, 23, 9, 230, 3,             // 1352:    check Inst[31:23] == 0x1e6
  OPC_CheckField, 4, 1, 1,                   // 1357:    check Inst[4] == 0x1
  OPC_Decode, 198, 14, 169, 4,               // 1361:    decode to NEON_VMINNMNQh using decoder 553
                                             // 1361:   }
                                             // 1361:   } // switch Inst[6]
                                             // 1361:  }
                                             // 1361:  } // switch Inst[21:20]
                                             // 1361: }
                                             // 1361: } // switch Inst[11:8]
};
// Handling 554 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, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 3, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 1:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 2:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 3, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 3:
    if (!Check(S, DecodeThumbAddSPReg(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 4:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 3);
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 3);
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 3, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 5:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 3);
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 3, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 6:
    tmp = fieldFromInstruction(insn, 3, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 7:
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 3, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 8:
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 3, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 9:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 8);
    if (!Check(S, DecodeThumbAddrModePC(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 10:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 3, 6);
    if (!Check(S, DecodeThumbAddrModeRR(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 11:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 3, 8);
    if (!Check(S, DecodeThumbAddrModeIS(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 12:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 8);
    if (!Check(S, DecodeThumbAddrModeSP(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 13:
    if (!Check(S, DecodeThumbAddSpecialReg(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 14:
    if (!Check(S, DecodeThumbAddSPImm(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 15:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 3, 5);
    tmp |= fieldFromInstruction(insn, 9, 1) << 5;
    if (!Check(S, DecodeThumbCmpBROperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 16:
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 8, 1) << 14;
    if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 17:
    tmp = fieldFromInstruction(insn, 3, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 18:
    if (!Check(S, DecodeThumbCPS(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 19:
    tmp = fieldFromInstruction(insn, 0, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 20:
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 8, 1) << 15;
    if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 21:
    tmp = fieldFromInstruction(insn, 0, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 22:
    tmp = fieldFromInstruction(insn, 4, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 23:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 0, 8);
    if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 24:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 0, 8);
    if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 25:
    return S;
  case 26:
    tmp = fieldFromInstruction(insn, 0, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 27:
    tmp = fieldFromInstruction(insn, 0, 8);
    if (!Check(S, DecodeThumbBCCTargetOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 28:
    tmp = fieldFromInstruction(insn, 0, 11);
    if (!Check(S, DecodeThumbBROperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 29:
    if (!Check(S, DecodeIT(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 30:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeCCOutOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 3, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 31:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeCCOutOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 3, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 32:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeCCOutOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 3, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 6, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 33:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeCCOutOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 0, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 34:
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeCCOutOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 35:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeCCOutOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 3, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 36:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeCCOutOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 3, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 37:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeCCOutOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 3, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 38:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 39:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 7) << 5;
    if (!Check(S, DecodeSORegImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 40:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 2) << 5;
    tmp |= fieldFromInstruction(insn, 8, 4) << 8;
    if (!Check(S, DecodeSORegRegOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 41:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 2) << 5;
    tmp |= fieldFromInstruction(insn, 8, 4) << 8;
    if (!Check(S, DecodeSORegRegOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 42:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 43:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 44:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 45:
    if (!Check(S, DecodeAddrMode3Instruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 46:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 47:
    if (!Check(S, DecodeCPSInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 48:
    tmp = fieldFromInstruction(insn, 9, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 49:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 50:
    if (!Check(S, DecodeQADDInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 51:
    if (!Check(S, DecodeSMLAInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 52:
    if (!Check(S, DecodeSwap(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 53:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 8, 12) << 4;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 54:
    if (!Check(S, DecodeTSTInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 55:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 7) << 5;
    if (!Check(S, DecodeSORegImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 56:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 2) << 5;
    tmp |= fieldFromInstruction(insn, 8, 4) << 8;
    if (!Check(S, DecodeSORegRegOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 57:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 58:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 59:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 60:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 61:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 62:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 63:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 8, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 5;
    if (!Check(S, DecodeBankedReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 64:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 16, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeMSRMask(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 65:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 8, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 5;
    if (!Check(S, DecodeBankedReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 66:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 67:
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 68:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 69:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 70:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodetcGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodetcGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 71:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 7) << 5;
    if (!Check(S, DecodeSORegImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 72:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 73:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 74:
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 75:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 2) << 5;
    tmp |= fieldFromInstruction(insn, 8, 4) << 8;
    if (!Check(S, DecodeSORegRegOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 76:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 77:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 78:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 79:
    if (!Check(S, DecodeDoubleRegStore(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 80:
    if (!Check(S, DecodeDoubleRegLoad(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 81:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 23, 1) << 4;
    if (!Check(S, DecodePostIdxReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 82:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 8, 4) << 4;
    tmp |= fieldFromInstruction(insn, 23, 1) << 8;
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 83:
    if (!Check(S, DecodeLDR(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 84:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 8, 4) << 4;
    tmp |= fieldFromInstruction(insn, 23, 1) << 8;
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 85:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 12);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 86:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 12);
    tmp |= fieldFromInstruction(insn, 22, 2) << 12;
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 87:
    if (!Check(S, DecodeArmMOVTWInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 88:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 12);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 89:
    if (!Check(S, DecodeTSBInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 90:
    if (!Check(S, DecodeHINTInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 91:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 16, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeMSRMask(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 12);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 92:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 12);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 93:
    if (!Check(S, DecodeAddrMode2IdxInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 94:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 12);
    tmp |= fieldFromInstruction(insn, 16, 4) << 13;
    tmp |= fieldFromInstruction(insn, 23, 1) << 12;
    if (!Check(S, DecodeAddrModeImm12Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 95:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 12);
    tmp |= fieldFromInstruction(insn, 16, 4) << 13;
    tmp |= fieldFromInstruction(insn, 23, 1) << 12;
    if (!Check(S, DecodeAddrModeImm12Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 96:
    if (!Check(S, DecodeSTRPreImm(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 97:
    if (!Check(S, DecodeLDRPreImm(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 98:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 12);
    tmp |= fieldFromInstruction(insn, 16, 4) << 13;
    tmp |= fieldFromInstruction(insn, 23, 1) << 12;
    if (!Check(S, DecodeAddrModeImm12Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 99:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeMemBarrierOption(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 100:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeInstSyncBarrierOption(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 101:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 7) << 5;
    tmp |= fieldFromInstruction(insn, 16, 4) << 13;
    tmp |= fieldFromInstruction(insn, 23, 1) << 12;
    if (!Check(S, DecodeSORegMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 102:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 7) << 5;
    tmp |= fieldFromInstruction(insn, 16, 4) << 13;
    tmp |= fieldFromInstruction(insn, 23, 1) << 12;
    if (!Check(S, DecodeSORegMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 103:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 104:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 7, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 105:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 106:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 107:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 108:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 109:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 110:
    if (!Check(S, DecodeSTRPreReg(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 111:
    if (!Check(S, DecodeLDRPreReg(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 112:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 6, 1) << 5;
    tmp |= fieldFromInstruction(insn, 7, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 113:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 114:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 7, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 115:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 7) << 5;
    tmp |= fieldFromInstruction(insn, 16, 4) << 13;
    tmp |= fieldFromInstruction(insn, 23, 1) << 12;
    if (!Check(S, DecodeSORegMemOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 116:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 5);
    tmp |= fieldFromInstruction(insn, 16, 5) << 5;
    if (!Check(S, DecodeBitfieldMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 117:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 5);
    tmp |= fieldFromInstruction(insn, 16, 5) << 5;
    if (!Check(S, DecodeBitfieldMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 118:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 119:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 120:
    if (!Check(S, DecodeMemMultipleWritebackInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 121:
    tmp = fieldFromInstruction(insn, 0, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 122:
    if (!Check(S, DecodeBranchImmInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 123:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 24) << 1;
    tmp |= fieldFromInstruction(insn, 24, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 124:
    if (!Check(S, DecoderForMRRC2AndMCRR2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 125:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 126:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 127:
    tmp = fieldFromInstruction(insn, 0, 24);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 128:
    if (!Check(S, DecodeCopMemInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 129:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 12, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 5, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 130:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 12, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 5, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 131:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 5, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 132:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 5, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 133:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 5, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 134:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 5, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 135:
    if (!Check(S, DecodeMveVCTP(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 136:
    if (!Check(S, DecodeMVEOverlappingLongShift(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 137:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 138:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 6, 2);
    tmp |= fieldFromInstruction(insn, 12, 3) << 2;
    if (!Check(S, DecodeLongShiftOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 139:
    tmp = fieldFromInstruction(insn, 17, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 9, 3) << 1;
    if (!Check(S, DecodetGPROddRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 9, 3) << 1;
    if (!Check(S, DecodetGPROddRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 6, 2);
    tmp |= fieldFromInstruction(insn, 12, 3) << 2;
    if (!Check(S, DecodeLongShiftOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 140:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 24, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 141:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 23, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 142:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 16, 4) << 3;
    if (!Check(S, DecodeMveAddrModeRQ(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 143:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 16, 3) << 8;
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeTAddrModeImm7<0>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 144:
    tmp = fieldFromInstruction(insn, 16, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeT2Imm7<0>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 145:
    if (!Check(S, DecodeMVE_MEM_1_pre<0>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 146:
    if (!Check(S, DecodeMVEVMOVQtoDReg(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 147:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 16, 3) << 8;
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeTAddrModeImm7<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 148:
    if (!Check(S, DecodeMVEVMOVDRegtoQ(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 149:
    tmp = fieldFromInstruction(insn, 16, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    if (!Check(S, DecodetGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeT2Imm7<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 150:
    if (!Check(S, DecodeMVE_MEM_1_pre<1>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 151:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 152:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 153:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 16, 4) << 8;
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeT2AddrModeImm7<0, 0>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 154:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 17, 3) << 8;
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeMveAddrModeQ<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 155:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 16, 4) << 8;
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeT2AddrModeImm7<1, 0>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 156:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 157:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 158:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeT2Imm7<0>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 159:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 160:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 161:
    if (!Check(S, DecodeMVE_MEM_2_pre<0>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 162:
    if (!Check(S, DecodeMVE_MEM_3_pre<2>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 163:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeT2Imm7<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 164:
    if (!Check(S, DecodeMVE_MEM_2_pre<1>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 165:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 166:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQQQQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 167:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 16, 4) << 8;
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeT2AddrModeImm7<2, 0>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 168:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 17, 3) << 8;
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeMveAddrModeQ<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 169:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 7);
    tmp |= fieldFromInstruction(insn, 23, 1) << 7;
    if (!Check(S, DecodeT2Imm7<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 170:
    if (!Check(S, DecodeMVE_MEM_2_pre<2>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 171:
    if (!Check(S, DecodeMVE_MEM_3_pre<3>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 172:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 16, 1) << 1;
    tmp |= fieldFromInstruction(insn, 21, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 173:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 6, 1);
    tmp |= fieldFromInstruction(insn, 16, 1) << 2;
    tmp |= fieldFromInstruction(insn, 21, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 174:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 5, 2);
    tmp |= fieldFromInstruction(insn, 16, 1) << 3;
    tmp |= fieldFromInstruction(insn, 21, 1) << 2;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 175:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 16, 1) << 1;
    tmp |= fieldFromInstruction(insn, 21, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 176:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 6, 1);
    tmp |= fieldFromInstruction(insn, 16, 1) << 2;
    tmp |= fieldFromInstruction(insn, 21, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 177:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 5, 2);
    tmp |= fieldFromInstruction(insn, 16, 1) << 3;
    tmp |= fieldFromInstruction(insn, 21, 1) << 2;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 178:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 179:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 180:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 181:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 182:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 1);
    tmp |= fieldFromInstruction(insn, 12, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 183:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 184:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 185:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 186:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 187:
    if (!Check(S, DecodeMVEVCMP<false,DecodeRestrictedIPredicateOperand>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 188:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeVPTMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 7, 1);
    if (!Check(S, DecodeRestrictedIPredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 189:
    if (!Check(S, DecodeMVEVCMP<false,DecodeRestrictedUPredicateOperand>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 190:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeVPTMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 7, 1);
    if (!Check(S, DecodeRestrictedUPredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 191:
    if (!Check(S, DecodeMVEVCMP<false,DecodeRestrictedSPredicateOperand>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 192:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeVPTMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 1) << 1;
    tmp |= fieldFromInstruction(insn, 7, 1);
    if (!Check(S, DecodeRestrictedSPredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 193:
    if (!Check(S, DecodeMVEVCMP<true,DecodeRestrictedIPredicateOperand>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 194:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeVPTMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRwithZRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 7, 1);
    if (!Check(S, DecodeRestrictedIPredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 195:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 1);
    tmp |= fieldFromInstruction(insn, 7, 1) << 1;
    if (!Check(S, DecodePowerTwoOperand<0,3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 196:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3) << 1;
    if (!Check(S, DecodetGPROddRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 1);
    tmp |= fieldFromInstruction(insn, 7, 1) << 1;
    if (!Check(S, DecodePowerTwoOperand<0,3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 197:
    if (!Check(S, DecodeMVEVCMP<true,DecodeRestrictedUPredicateOperand>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 198:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeVPTMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRwithZRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 7, 1);
    if (!Check(S, DecodeRestrictedUPredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 199:
    if (!Check(S, DecodeMVEVCMP<true,DecodeRestrictedSPredicateOperand>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 200:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeVPTMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRwithZRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 5, 1) << 1;
    tmp |= fieldFromInstruction(insn, 7, 1);
    if (!Check(S, DecodeRestrictedSPredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 201:
    if (!Check(S, DecodeMVEVADCInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 202:
    if (!Check(S, DecodeMVEVCMP<false,DecodeRestrictedFPPredicateOperand>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 203:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeVPTMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 1) << 1;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 12, 1) << 2;
    if (!Check(S, DecodeRestrictedFPPredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 204:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 205:
    if (!Check(S, DecodeMVEVCMP<true,DecodeRestrictedFPPredicateOperand>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 206:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeVPTMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRwithZRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 5, 1) << 1;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 12, 1) << 2;
    if (!Check(S, DecodeRestrictedFPPredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 207:
    if (!Check(S, DecodeMVEVPNOT(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 208:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeVPTMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 209:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 210:
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 211:
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 3) << 1;
    if (!Check(S, DecodetGPROddRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 212:
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 213:
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 3) << 1;
    if (!Check(S, DecodetGPROddRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 3) << 1;
    if (!Check(S, DecodetGPROddRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 214:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 215:
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 216:
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 3) << 1;
    if (!Check(S, DecodetGPROddRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 217:
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 218:
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 3) << 1;
    if (!Check(S, DecodetGPROddRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3) << 1;
    if (!Check(S, DecodetGPREvenRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 3) << 1;
    if (!Check(S, DecodetGPROddRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 219:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 220:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    if (!Check(S, DecodeShiftRight8Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 221:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeShiftRight16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 222:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 223:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 224:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeLongShiftOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 225:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 3;
    tmp |= fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 226:
    if (!Check(S, DecodeMVEModImmInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 227:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 9, 2) << 9;
    tmp |= fieldFromInstruction(insn, 16, 3) << 4;
    tmp |= fieldFromInstruction(insn, 28, 1) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 228:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 9, 1) << 9;
    tmp |= fieldFromInstruction(insn, 16, 3) << 4;
    tmp |= fieldFromInstruction(insn, 28, 1) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 229:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    if (!Check(S, DecodeShiftRight8Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 230:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 231:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeShiftRight16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 232:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 233:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeShiftRight32Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 234:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeShiftRight32Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 235:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 236:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 13, 3);
    tmp |= fieldFromInstruction(insn, 22, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 3);
    tmp |= fieldFromInstruction(insn, 5, 1) << 3;
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 237:
    if (!Check(S, DecodeMVEVCVTt1fp(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 238:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 239:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 240:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 241:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 242:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 243:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 244:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 245:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 246:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 247:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 248:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeDPR_8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 3, 1);
    tmp |= fieldFromInstruction(insn, 5, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 249:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeDPR_8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 3, 1);
    tmp |= fieldFromInstruction(insn, 5, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 250:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeDPR_8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 3, 1);
    tmp |= fieldFromInstruction(insn, 5, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 251:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeDPR_8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 3, 1);
    tmp |= fieldFromInstruction(insn, 5, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 252:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeDPR_8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 3, 1);
    tmp |= fieldFromInstruction(insn, 5, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 253:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeDPR_8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 3, 1);
    tmp |= fieldFromInstruction(insn, 5, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 254:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 255:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 256:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 257:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 258:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 259:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 260:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 261:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 262:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 9, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 263:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 264:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 11, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 265:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 266:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 9, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 267:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 268:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 269:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 270:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 271:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 272:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 273:
    if (!Check(S, DecodeVSHLMaxInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 274:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 275:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 276:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 277:
    if (!Check(S, DecodeTBLInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 278:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 19, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 279:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 280:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 281:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 19, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 282:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 283:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 284:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    if (!Check(S, DecodeShiftRight8Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 285:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeShiftRight16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 286:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeShiftRight32Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 287:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    if (!Check(S, DecodeShiftRight8Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 288:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeShiftRight16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 289:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeShiftRight32Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 290:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 291:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 292:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 293:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 294:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 295:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 296:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    if (!Check(S, DecodeShiftRight8Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 297:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeShiftRight16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 298:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeShiftRight32Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 299:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 300:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 301:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 302:
    if (!Check(S, DecodeVCVTD(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 303:
    if (!Check(S, DecodeVMOVModImmInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 304:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    if (!Check(S, DecodeShiftRight64Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 305:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    if (!Check(S, DecodeShiftRight64Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 306:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 307:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 308:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    if (!Check(S, DecodeShiftRight8Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 309:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeShiftRight16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 310:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeShiftRight32Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 311:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    if (!Check(S, DecodeShiftRight8Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 312:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeShiftRight16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 313:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    if (!Check(S, DecodeShiftRight32Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 314:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 315:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 316:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 317:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 318:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 319:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 320:
    if (!Check(S, DecodeVCVTQ(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 321:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    if (!Check(S, DecodeShiftRight64Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 322:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    if (!Check(S, DecodeShiftRight64Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 323:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 324:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 325:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 326:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 327:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 6, 1);
    tmp |= fieldFromInstruction(insn, 21, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 328:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 6, 1);
    tmp |= fieldFromInstruction(insn, 21, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 329:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 5, 2);
    tmp |= fieldFromInstruction(insn, 21, 1) << 2;
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 330:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 5, 2);
    tmp |= fieldFromInstruction(insn, 21, 1) << 2;
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 331:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 332:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 333:
    if (!Check(S, DecodeVLDST4Instruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 334:
    if (!Check(S, DecodeVST1LN(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 335:
    if (!Check(S, DecodeVLD1LN(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 336:
    if (!Check(S, DecodeVST2LN(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 337:
    if (!Check(S, DecodeVLD2LN(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 338:
    if (!Check(S, DecodeVLDST1Instruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 339:
    if (!Check(S, DecodeVST3LN(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 340:
    if (!Check(S, DecodeVLD3LN(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 341:
    if (!Check(S, DecodeVLDST2Instruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 342:
    if (!Check(S, DecodeVST4LN(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 343:
    if (!Check(S, DecodeVLD4LN(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 344:
    if (!Check(S, DecodeVLDST3Instruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 345:
    if (!Check(S, DecodeVLD1DupInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 346:
    if (!Check(S, DecodeVLD2DupInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 347:
    if (!Check(S, DecodeVLD3DupInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 348:
    if (!Check(S, DecodeVLD4DupInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 349:
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 10) << 1;
    tmp |= fieldFromInstruction(insn, 11, 1) << 21;
    tmp |= fieldFromInstruction(insn, 13, 1) << 22;
    tmp |= fieldFromInstruction(insn, 16, 10) << 11;
    tmp |= fieldFromInstruction(insn, 26, 1) << 23;
    if (!Check(S, DecodeThumbBLXOffset(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 350:
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 11);
    tmp |= fieldFromInstruction(insn, 11, 1) << 21;
    tmp |= fieldFromInstruction(insn, 13, 1) << 22;
    tmp |= fieldFromInstruction(insn, 16, 10) << 11;
    tmp |= fieldFromInstruction(insn, 26, 1) << 23;
    if (!Check(S, DecodeThumbBLTargetOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 351:
    tmp = fieldFromInstruction(insn, 0, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 352:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 353:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 13);
    tmp |= fieldFromInstruction(insn, 14, 1) << 14;
    if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 354:
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 13);
    tmp |= fieldFromInstruction(insn, 14, 2) << 14;
    if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 355:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 356:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 357:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 4, 4) << 5;
    tmp |= fieldFromInstruction(insn, 12, 3) << 9;
    if (!Check(S, DecodeSORegImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 358:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 359:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 4, 4) << 5;
    tmp |= fieldFromInstruction(insn, 12, 3) << 9;
    if (!Check(S, DecodeSORegImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 360:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 361:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 4, 4) << 5;
    tmp |= fieldFromInstruction(insn, 12, 3) << 9;
    if (!Check(S, DecodeSORegImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 362:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 363:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 4, 4) << 5;
    tmp |= fieldFromInstruction(insn, 12, 3) << 9;
    if (!Check(S, DecodeSORegImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 364:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 13);
    tmp |= fieldFromInstruction(insn, 14, 1) << 14;
    if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 365:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 0, 16);
    if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 366:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 367:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 16, 4) << 8;
    if (!Check(S, DecodeT2AddrModeImm0_1020s4(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 368:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 369:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 370:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 371:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 16, 4) << 8;
    if (!Check(S, DecodeT2AddrModeImm0_1020s4(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 372:
    if (!Check(S, DecodeThumbTableBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 373:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 374:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 16, 4) << 9;
    tmp |= fieldFromInstruction(insn, 23, 1) << 8;
    if (!Check(S, DecodeT2AddrModeImm8s4(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 375:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 376:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 377:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 6, 2);
    tmp |= fieldFromInstruction(insn, 12, 3) << 2;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 378:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRwithZRnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRwithZRnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 4);
    if (!Check(S, DecodePredNoALOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 379:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 6, 2);
    tmp |= fieldFromInstruction(insn, 12, 3) << 2;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 380:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 23, 1) << 8;
    if (!Check(S, DecodeT2Imm8S4(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 381:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeAddrMode7Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 23, 1) << 8;
    if (!Check(S, DecodeT2Imm8S4(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 382:
    if (!Check(S, DecodeT2STRDPreInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 383:
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 384:
    if (!Check(S, DecodeT2LDRDPreInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 385:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 4, 4) << 5;
    tmp |= fieldFromInstruction(insn, 12, 3) << 9;
    if (!Check(S, DecodeSORegImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 386:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 12, 3) << 8;
    tmp |= fieldFromInstruction(insn, 26, 1) << 11;
    if (!Check(S, DecodeT2SOImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 387:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 12, 3) << 8;
    tmp |= fieldFromInstruction(insn, 26, 1) << 11;
    if (!Check(S, DecodeT2SOImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 388:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 12, 3) << 8;
    tmp |= fieldFromInstruction(insn, 26, 1) << 11;
    if (!Check(S, DecodeT2SOImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 389:
    if (!Check(S, DecodeT2AddSubSPImm(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 390:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 12, 3) << 8;
    tmp |= fieldFromInstruction(insn, 26, 1) << 11;
    if (!Check(S, DecodeT2SOImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 391:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 12, 3) << 8;
    tmp |= fieldFromInstruction(insn, 26, 1) << 11;
    if (!Check(S, DecodeT2SOImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 20, 1);
    if (!Check(S, DecodeCCOutOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 392:
    if (!Check(S, DecodeT2Adr(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 393:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 12, 3) << 8;
    tmp |= fieldFromInstruction(insn, 26, 1) << 11;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 394:
    if (!Check(S, DecodeT2MOVTWInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 395:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 396:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 6, 2);
    tmp |= fieldFromInstruction(insn, 12, 3) << 2;
    tmp |= fieldFromInstruction(insn, 21, 1) << 5;
    if (!Check(S, DecodeT2ShifterImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 397:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 6, 2);
    tmp |= fieldFromInstruction(insn, 12, 3) << 2;
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 398:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 5) << 5;
    tmp |= fieldFromInstruction(insn, 6, 2);
    tmp |= fieldFromInstruction(insn, 12, 3) << 2;
    if (!Check(S, DecodeBitfieldMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 399:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 5) << 5;
    tmp |= fieldFromInstruction(insn, 6, 2);
    tmp |= fieldFromInstruction(insn, 12, 3) << 2;
    if (!Check(S, DecodeBitfieldMaskOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 400:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 401:
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 402:
    if (!Check(S, DecodeT2HintSpaceInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 403:
    if (!Check(S, DecodeT2CPSInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 404:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeMemBarrierOption(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 405:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeInstSyncBarrierOption(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 406:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 407:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 12);
    tmp |= fieldFromInstruction(insn, 16, 4) << 12;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 408:
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 409:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 8, 4);
    tmp |= fieldFromInstruction(insn, 20, 1) << 4;
    if (!Check(S, DecodeMSRMask(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 410:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1) << 4;
    tmp |= fieldFromInstruction(insn, 8, 4);
    tmp |= fieldFromInstruction(insn, 20, 1) << 5;
    if (!Check(S, DecodeBankedReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 411:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 10, 2) << 10;
    if (!Check(S, DecodeMSRMask(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 412:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    tmp |= fieldFromInstruction(insn, 20, 1) << 5;
    if (!Check(S, DecodeBankedReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 413:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 8);
    if (!Check(S, DecodeMSRMask(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 414:
    if (!Check(S, DecodeThumb2BCCInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 415:
    if (!Check(S, DecodeLOLoop(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 416:
    tmp = fieldFromInstruction(insn, 23, 4);
    if (!Check(S, DecodeBFLabelOperand<false, false, false, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 10) << 1;
    tmp |= fieldFromInstruction(insn, 11, 1);
    tmp |= fieldFromInstruction(insn, 16, 7) << 11;
    if (!Check(S, DecodeBFLabelOperand<true, false, true, 18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 417:
    tmp = fieldFromInstruction(insn, 23, 4);
    if (!Check(S, DecodeBFLabelOperand<false, false, false, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 10) << 1;
    tmp |= fieldFromInstruction(insn, 11, 1);
    tmp |= fieldFromInstruction(insn, 16, 1) << 11;
    if (!Check(S, DecodeBFLabelOperand<true, false, true, 12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 1);
    if (!Check(S, DecodeBFAfterTargetOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 4);
    if (!Check(S, DecodePredNoALOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 418:
    tmp = fieldFromInstruction(insn, 23, 4);
    if (!Check(S, DecodeBFLabelOperand<false, false, false, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 10) << 1;
    tmp |= fieldFromInstruction(insn, 11, 1);
    tmp |= fieldFromInstruction(insn, 16, 5) << 11;
    if (!Check(S, DecodeBFLabelOperand<true, false, true, 16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 419:
    tmp = fieldFromInstruction(insn, 23, 4);
    if (!Check(S, DecodeBFLabelOperand<false, false, false, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 420:
    if (!Check(S, DecodeT2BInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 421:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 2;
    tmp |= fieldFromInstruction(insn, 4, 2);
    tmp |= fieldFromInstruction(insn, 16, 4) << 6;
    if (!Check(S, DecodeT2AddrModeSOReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 422:
    if (!Check(S, DecodeT2LdStPre(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 423:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 16, 4) << 9;
    if (!Check(S, DecodeT2AddrModeImm8(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 424:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 9, 1) << 8;
    tmp |= fieldFromInstruction(insn, 16, 4) << 9;
    if (!Check(S, DecodeT2AddrModeImm8(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 425:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x1000;
    tmp |= fieldFromInstruction(insn, 0, 12);
    tmp |= fieldFromInstruction(insn, 16, 4) << 13;
    if (!Check(S, DecodeT2AddrModeImm12(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 426:
    if (!Check(S, DecodeT2LoadShift(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 427:
    if (!Check(S, DecodeT2LoadImm8(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 428:
    if (!Check(S, DecodeT2LoadT(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 429:
    if (!Check(S, DecodeT2LoadImm12(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 430:
    if (!Check(S, DecodeT2LoadLabel(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 431:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 432:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 433:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 434:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 435:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 436:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 437:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 438:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 439:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 2;
    tmp |= fieldFromInstruction(insn, 4, 2);
    tmp |= fieldFromInstruction(insn, 16, 4) << 6;
    if (!Check(S, DecodeT2AddrModeSOReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 440:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 9, 1) << 8;
    tmp |= fieldFromInstruction(insn, 16, 4) << 9;
    if (!Check(S, DecodeT2AddrModeImm8(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 441:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x1000;
    tmp |= fieldFromInstruction(insn, 0, 12);
    tmp |= fieldFromInstruction(insn, 16, 4) << 13;
    if (!Check(S, DecodeT2AddrModeImm12(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 442:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 443:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 444:
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 445:
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 446:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRnopcRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 447:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 16, 4) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 448:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 7, 1) << 1;
    tmp |= fieldFromInstruction(insn, 16, 4) << 2;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 449:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 20, 2) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 450:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 16, 4) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 451:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 7, 1) << 1;
    tmp |= fieldFromInstruction(insn, 16, 4) << 2;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 452:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 20, 2) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 453:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 16, 4) << 7;
    tmp |= fieldFromInstruction(insn, 24, 1) << 11;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 454:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 7, 1) << 1;
    tmp |= fieldFromInstruction(insn, 16, 4) << 2;
    tmp |= fieldFromInstruction(insn, 24, 1) << 6;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 455:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 20, 2) << 1;
    tmp |= fieldFromInstruction(insn, 24, 1) << 3;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredROperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 456:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 16, 6) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 457:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 20, 2) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 458:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 2);
    tmp |= fieldFromInstruction(insn, 7, 1) << 2;
    tmp |= fieldFromInstruction(insn, 20, 3) << 3;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 459:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRPairnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 16, 6) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 460:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRPairnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 20, 2) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 461:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRPairnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 2);
    tmp |= fieldFromInstruction(insn, 7, 1) << 2;
    tmp |= fieldFromInstruction(insn, 20, 3) << 3;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 462:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 16, 4) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 463:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 7, 1) << 1;
    tmp |= fieldFromInstruction(insn, 16, 4) << 2;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 464:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 20, 2) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 465:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 16, 4) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 466:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 7, 1) << 1;
    tmp |= fieldFromInstruction(insn, 16, 4) << 2;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 467:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 20, 2) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 468:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 16, 4) << 7;
    tmp |= fieldFromInstruction(insn, 24, 1) << 11;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 469:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 7, 1) << 1;
    tmp |= fieldFromInstruction(insn, 16, 4) << 2;
    tmp |= fieldFromInstruction(insn, 24, 1) << 6;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 470:
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 13, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 17, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 1, 3);
    if (!Check(S, DecodeMQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 1);
    tmp |= fieldFromInstruction(insn, 20, 2) << 1;
    tmp |= fieldFromInstruction(insn, 24, 1) << 3;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodeVpredNOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 471:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 16, 6) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 472:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 20, 2) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 473:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 2);
    tmp |= fieldFromInstruction(insn, 7, 1) << 2;
    tmp |= fieldFromInstruction(insn, 20, 3) << 3;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 474:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRPairnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRPairnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 16, 6) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 475:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRPairnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRPairnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 6);
    tmp |= fieldFromInstruction(insn, 7, 1) << 6;
    tmp |= fieldFromInstruction(insn, 20, 2) << 7;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 476:
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRPairnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 3);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeGPRPairnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSR_NZCVnospRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 4, 2);
    tmp |= fieldFromInstruction(insn, 7, 1) << 2;
    tmp |= fieldFromInstruction(insn, 20, 3) << 3;
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 477:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 478:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 4, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 479:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 20, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 12, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 5, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 480:
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 5, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 481:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRwithAPSRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 8, 4);
    if (!Check(S, DecodeCoprocessor(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 21, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 16, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 5, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    if (!Check(S, DecodePredicateOperand(MI, Decoder)))
      return MCDisassembler::Fail;
    return S;
  case 482:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 16, 4) << 9;
    tmp |= fieldFromInstruction(insn, 23, 1) << 8;
    if (!Check(S, DecodeAddrMode5FP16Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 483:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 484:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 485:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 486:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecoderGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 487:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 16, 4) << 4;
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 488:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 489:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 490:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 491:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 492:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 493:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 494:
    if (!Check(S, DecodeVMOVSRR(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 495:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 12, 4) << 9;
    tmp |= fieldFromInstruction(insn, 22, 1) << 8;
    if (!Check(S, DecodeSPRRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 496:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 16, 4) << 9;
    tmp |= fieldFromInstruction(insn, 23, 1) << 8;
    if (!Check(S, DecodeAddrMode5Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 497:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 498:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 499:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 500:
    if (!Check(S, DecodeVMOVRRS(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 501:
    if (!Check(S, DecodeVSCCLRM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 502:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 503:
    if (!Check(S, DecodeLazyLoadStoreMul(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 504:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 12, 4) << 9;
    tmp |= fieldFromInstruction(insn, 22, 1) << 8;
    if (!Check(S, DecodeSPRRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 505:
    if (!Check(S, DecodeForVMRSandVMSR(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 506:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 16, 4) << 4;
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 507:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 508:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 509:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 510:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 511:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 7) << 1;
    tmp |= fieldFromInstruction(insn, 12, 4) << 8;
    tmp |= fieldFromInstruction(insn, 22, 1) << 12;
    if (!Check(S, DecodeDPRRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 512:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 7) << 1;
    tmp |= fieldFromInstruction(insn, 12, 4) << 8;
    if (!Check(S, DecodeDPRRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 513:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 8);
    tmp |= fieldFromInstruction(insn, 16, 4) << 9;
    tmp |= fieldFromInstruction(insn, 23, 1) << 8;
    if (!Check(S, DecodeAddrMode5Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 514:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 515:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 516:
    tmp = fieldFromInstruction(insn, 12, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 517:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 7) << 1;
    tmp |= fieldFromInstruction(insn, 12, 4) << 8;
    tmp |= fieldFromInstruction(insn, 22, 1) << 12;
    if (!Check(S, DecodeDPRRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 518:
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 1, 7) << 1;
    tmp |= fieldFromInstruction(insn, 12, 4) << 8;
    if (!Check(S, DecodeDPRRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 519:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 16, 4) << 4;
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 520:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 521:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 522:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 523:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 524:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 28, 4);
    if (!Check(S, DecodePredicateOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 525:
    if (!Check(S, DecodeVSTRVLDR_SYSREG<false>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 526:
    if (!Check(S, DecodeVSTRVLDR_SYSREG<true>(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 527:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 24, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 528:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 23, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 529:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 20, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 530:
    if (!Check(S, DecodeNEONComplexLane64Instruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 531:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 24, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 532:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 23, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 533:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 20, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 534:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 3) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPR_8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 3, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 535:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeDPR_8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 3, 1);
    tmp |= fieldFromInstruction(insn, 5, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 536:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 537:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 538:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeDPR_8RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 3, 1);
    tmp |= fieldFromInstruction(insn, 5, 1) << 1;
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 539:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 540:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 541:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeHPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 542:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1);
    tmp |= fieldFromInstruction(insn, 16, 4) << 1;
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 543:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 544:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4) << 1;
    tmp |= fieldFromInstruction(insn, 5, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 545:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 546:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 547:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4) << 1;
    tmp |= fieldFromInstruction(insn, 22, 1);
    if (!Check(S, DecodeSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 548:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 549:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeDPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 550:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    if (!Check(S, DecodeDPR_VFP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 551:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 552:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 553:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 12, 4);
    tmp |= fieldFromInstruction(insn, 22, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 7, 1) << 4;
    tmp |= fieldFromInstruction(insn, 16, 4);
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 4);
    tmp |= fieldFromInstruction(insn, 5, 1) << 4;
    if (!Check(S, DecodeQPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  }
}
static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) {
  switch (Idx) {
  default: llvm_unreachable("Invalid index!");
  case 0:
    return FB[ARM::ModeThumb];
  case 1:
    return FB[ARM::ModeThumb] && FB[ARM::Feature8MSecExt];
  case 2:
    return FB[ARM::ModeThumb] && FB[ARM::HasV5TOps];
  case 3:
    return FB[ARM::ModeThumb] && FB[ARM::HasV6Ops];
  case 4:
    return FB[ARM::ModeThumb] && FB[ARM::HasV8MBaselineOps];
  case 5:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && FB[ARM::HasV8Ops] && FB[ARM::HasV8_1aOps];
  case 6:
    return FB[ARM::ModeThumb] && !FB[ARM::FeatureMClass];
  case 7:
    return FB[ARM::ModeThumb] && FB[ARM::HasV8Ops];
  case 8:
    return FB[ARM::ModeThumb] && FB[ARM::HasV6MOps];
  case 9:
    return FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2];
  case 10:
    return !FB[ARM::ModeThumb];
  case 11:
    return !FB[ARM::ModeThumb] && FB[ARM::HasV6Ops];
  case 12:
    return !FB[ARM::ModeThumb] && FB[ARM::FeatureCRC];
  case 13:
    return !FB[ARM::ModeThumb] && FB[ARM::HasV5TEOps];
  case 14:
    return !FB[ARM::ModeThumb] && !FB[ARM::HasV8Ops];
  case 15:
    return !FB[ARM::ModeThumb] && FB[ARM::HasV8Ops];
  case 16:
    return !FB[ARM::ModeThumb] && FB[ARM::HasV8Ops] && FB[ARM::HasV8_1aOps];
  case 17:
    return !FB[ARM::ModeThumb] && FB[ARM::FeatureVirtualization];
  case 18:
    return !FB[ARM::ModeThumb] && FB[ARM::FeatureAcquireRelease];
  case 19:
    return !FB[ARM::ModeThumb] && FB[ARM::FeatureAcquireRelease] && FB[ARM::FeatureV7Clrex];
  case 20:
    return !FB[ARM::ModeThumb] && FB[ARM::HasV4TOps];
  case 21:
    return !FB[ARM::ModeThumb] && FB[ARM::HasV5TOps];
  case 22:
    return !FB[ARM::ModeThumb] && FB[ARM::FeatureTrustZone];
  case 23:
    return !FB[ARM::ModeThumb] && FB[ARM::HasV6T2Ops];
  case 24:
    return !FB[ARM::ModeThumb] && FB[ARM::HasV8_4aOps];
  case 25:
    return !FB[ARM::ModeThumb] && FB[ARM::HasV7Ops];
  case 26:
    return !FB[ARM::ModeThumb] && FB[ARM::HasV7Ops] && FB[ARM::FeatureMP];
  case 27:
    return !FB[ARM::ModeThumb] && FB[ARM::HasV6KOps];
  case 28:
    return !FB[ARM::ModeThumb] && FB[ARM::FeatureDB];
  case 29:
    return !FB[ARM::ModeThumb] && FB[ARM::FeatureSB];
  case 30:
    return !FB[ARM::ModeThumb] && FB[ARM::FeatureHWDivARM];
  case 31:
    return FB[ARM::HasMVEIntegerOps];
  case 32:
    return FB[ARM::HasV8_1MMainlineOps] && FB[ARM::HasMVEIntegerOps];
  case 33:
    return FB[ARM::HasMVEFloatOps];
  case 34:
    return FB[ARM::FeatureFPRegs] && FB[ARM::HasV8_1MMainlineOps];
  case 35:
    return FB[ARM::FeatureNEON];
  case 36:
    return FB[ARM::FeatureNEON] && FB[ARM::FeatureFullFP16];
  case 37:
    return FB[ARM::FeatureNEON] && FB[ARM::HasV8_1aOps];
  case 38:
    return FB[ARM::HasV8Ops] && FB[ARM::FeatureAES];
  case 39:
    return FB[ARM::FeatureNEON] && FB[ARM::FeatureFP16];
  case 40:
    return FB[ARM::FeatureBF16] && FB[ARM::FeatureNEON];
  case 41:
    return FB[ARM::FeatureNEON] && FB[ARM::FeatureVFP4_D16_SP];
  case 42:
    return FB[ARM::FeatureVFP2_SP];
  case 43:
    return FB[ARM::FeatureFPRegs];
  case 44:
    return FB[ARM::ModeThumb] && FB[ARM::HasV5TOps] && !FB[ARM::FeatureMClass];
  case 45:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && !FB[ARM::FeatureMClass];
  case 46:
    return FB[ARM::HasV8_1MMainlineOps];
  case 47:
    return FB[ARM::ModeThumb] && FB[ARM::FeatureAcquireRelease];
  case 48:
    return FB[ARM::ModeThumb] && FB[ARM::FeatureAcquireRelease] && FB[ARM::FeatureV7Clrex];
  case 49:
    return FB[ARM::ModeThumb] && FB[ARM::FeatureAcquireRelease] && FB[ARM::FeatureV7Clrex] && !FB[ARM::FeatureMClass];
  case 50:
    return FB[ARM::FeatureDSP] && (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]);
  case 51:
    return FB[ARM::Feature8MSecExt];
  case 52:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && FB[ARM::FeatureDSP];
  case 53:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && FB[ARM::HasV8Ops];
  case 54:
    return FB[ARM::ModeThumb] && FB[ARM::HasV8_4aOps];
  case 55:
    return FB[ARM::ModeThumb] && FB[ARM::FeatureV7Clrex];
  case 56:
    return FB[ARM::ModeThumb] && FB[ARM::FeatureDB];
  case 57:
    return FB[ARM::HasV7Ops] && FB[ARM::FeatureMClass];
  case 58:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && FB[ARM::FeatureSB];
  case 59:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && FB[ARM::FeatureVirtualization];
  case 60:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && FB[ARM::FeatureTrustZone];
  case 61:
    return FB[ARM::ModeThumb] && FB[ARM::FeatureVirtualization];
  case 62:
    return FB[ARM::ModeThumb] && FB[ARM::FeatureMClass];
  case 63:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && FB[ARM::HasV8_1MMainlineOps] && FB[ARM::FeatureLOB];
  case 64:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && FB[ARM::HasV7Ops];
  case 65:
    return FB[ARM::FeatureHWDivThumb] && FB[ARM::ModeThumb] && FB[ARM::HasV8MBaselineOps];
  case 66:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && FB[ARM::HasV7Ops] && FB[ARM::FeatureMP];
  case 67:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && FB[ARM::FeatureCRC];
  case 68:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && FB[ARM::HasV8_1MMainlineOps] && FB[ARM::FeaturePACBTI];
  case 69:
    return FB[ARM::HasCDEOps] && FB[ARM::FeatureFPRegs];
  case 70:
    return FB[ARM::HasCDEOps] && FB[ARM::HasMVEIntegerOps];
  case 71:
    return FB[ARM::HasCDEOps];
  case 72:
    return (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]) && !FB[ARM::HasV8Ops];
  case 73:
    return !FB[ARM::HasV8Ops] && (FB[ARM::ModeThumb] && FB[ARM::FeatureThumb2]);
  case 74:
    return FB[ARM::FeatureFPRegs16];
  case 75:
    return FB[ARM::FeatureFullFP16];
  case 76:
    return FB[ARM::HasV8_1MMainlineOps] && FB[ARM::Feature8MSecExt];
  case 77:
    return FB[ARM::FeatureVFP4_D16_SP];
  case 78:
    return FB[ARM::HasV8MMainlineOps] && FB[ARM::Feature8MSecExt];
  case 79:
    return FB[ARM::HasV8_1MMainlineOps] && FB[ARM::FeatureFPRegs];
  case 80:
    return FB[ARM::FeatureVFP3_D16_SP];
  case 81:
    return FB[ARM::FeatureFP16];
  case 82:
    return FB[ARM::FeatureFPARMv8_D16_SP];
  case 83:
    return FB[ARM::FeatureVFP2_SP] && FB[ARM::FeatureFP64];
  case 84:
    return FB[ARM::FeatureVFP4_D16_SP] && FB[ARM::FeatureFP64];
  case 85:
    return FB[ARM::FeatureVFP3_D16_SP] && FB[ARM::FeatureFP64];
  case 86:
    return FB[ARM::FeatureFPRegs64];
  case 87:
    return FB[ARM::FeatureFPARMv8_D16_SP] && FB[ARM::FeatureFP64];
  case 88:
    return FB[ARM::FeatureFPARMv8_D16_SP] && FB[ARM::HasV8_3aOps];
  case 89:
    return FB[ARM::FeatureNEON] && FB[ARM::HasV8_3aOps] && FB[ARM::FeatureFullFP16];
  case 90:
    return FB[ARM::FeatureNEON] && FB[ARM::HasV8_3aOps];
  case 91:
    return FB[ARM::FeatureNEON] && FB[ARM::FeatureFP16FML];
  case 92:
    return FB[ARM::FeatureBF16];
  case 93:
    return FB[ARM::FeatureMatMulInt8];
  case 94:
    return FB[ARM::FeatureDotProd];
  case 95:
    return FB[ARM::HasV8Ops] && FB[ARM::FeatureSHA2];
  case 96:
    return FB[ARM::HasV8Ops] && FB[ARM::FeatureNEON] && FB[ARM::FeatureFullFP16];
  case 97:
    return FB[ARM::HasV8Ops] && FB[ARM::FeatureNEON];
  case 98:
    return FB[ARM::FeatureFPARMv8_D16_SP] && FB[ARM::FeatureNEON];
  case 99:
    return FB[ARM::FeatureFPARMv8_D16_SP] && FB[ARM::FeatureNEON] && FB[ARM::FeatureFullFP16];
  }
}


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

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

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

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

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

      if (DecodeComplete) {
        LLVM_DEBUG(dbgs() << "decoding complete\n");
        return S;
      }
      assert(S == MCDisassembler::Fail);
      // Reset decode status. This also drops a SoftFail status that could be
      // set before the decode attempt.
      S = MCDisassembler::Success;
      break;
    }
    case OPC_SoftFail: {
      // Decode the mask values.
      uint64_t PositiveMask = decodeULEB128AndIncUnsafe(Ptr);
      uint64_t NegativeMask = decodeULEB128AndIncUnsafe(Ptr);
      bool Failed = (insn & PositiveMask) != 0 || (~insn & NegativeMask) != 0;
      if (Failed)
        S = MCDisassembler::SoftFail;
      LLVM_DEBUG(dbgs() << Loc << ": OPC_SoftFail: " << (Failed ? "FAIL\n" : "PASS\n"));
      continue;
    }
    }
    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
