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


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

namespace {

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

static const uint8_t DecoderTable32[16024] = {
  OPC_SwitchField, 26, 6,                    //     0: switch Inst[31:26] {
  0, 218, 21,                                //     3: case 0x0: {
  OPC_SwitchField, 22, 4,                    //     6:  switch Inst[25:22] {
  0, 225, 12,                                //     9:  case 0x0: {
  OPC_SwitchField, 18, 4,                    //    12:   switch Inst[21:18] {
  0, 252, 2,                                 //    15:   case 0x0: {
  OPC_SwitchField, 15, 3,                    //    18:    switch Inst[17:15] {
  0, 227, 1,                                 //    21:    case 0x0: {
  OPC_SwitchField, 10, 5,                    //    24:     switch Inst[14:10] {
  2, 8,                                      //    27:     case 0x2: {
  OPC_CheckField, 2, 3, 0,                   //    29:      check Inst[4:2] == 0x0
  OPC_Decode, 168, 6, 0,                     //    33:      decode to MOVGR2SCR using decoder 0
                                             //    33:     }
  3, 8,                                      //    37:     case 0x3: {
  OPC_CheckField, 7, 3, 0,                   //    39:      check Inst[9:7] == 0x0
  OPC_Decode, 169, 6, 1,                     //    43:      decode to MOVSCR2GR using decoder 1
                                             //    43:     }
  4, 4,                                      //    47:     case 0x4: {
  OPC_Decode, 179, 4, 2,                     //    49:      decode to CLO_W using decoder 2
                                             //    49:     }
  5, 4,                                      //    53:     case 0x5: {
  OPC_Decode, 181, 4, 2,                     //    55:      decode to CLZ_W using decoder 2
                                             //    55:     }
  6, 4,                                      //    59:     case 0x6: {
  OPC_Decode, 195, 4, 2,                     //    61:      decode to CTO_W using decoder 2
                                             //    61:     }
  7, 4,                                      //    65:     case 0x7: {
  OPC_Decode, 197, 4, 2,                     //    67:      decode to CTZ_W using decoder 2
                                             //    67:     }
  8, 6,                                      //    71:     case 0x8: {
  OPC_CheckPredicate, 0,                     //    73:      check predicate 0
  OPC_Decode, 178, 4, 2,                     //    75:      decode to CLO_D using decoder 2
                                             //    75:     }
  9, 6,                                      //    79:     case 0x9: {
  OPC_CheckPredicate, 0,                     //    81:      check predicate 0
  OPC_Decode, 180, 4, 2,                     //    83:      decode to CLZ_D using decoder 2
                                             //    83:     }
  10, 6,                                     //    87:     case 0xa: {
  OPC_CheckPredicate, 0,                     //    89:      check predicate 0
  OPC_Decode, 194, 4, 2,                     //    91:      decode to CTO_D using decoder 2
                                             //    91:     }
  11, 6,                                     //    95:     case 0xb: {
  OPC_CheckPredicate, 0,                     //    97:      check predicate 0
  OPC_Decode, 196, 4, 2,                     //    99:      decode to CTZ_D using decoder 2
                                             //    99:     }
  12, 4,                                     //   103:     case 0xc: {
  OPC_Decode, 199, 6, 2,                     //   105:      decode to REVB_2H using decoder 2
                                             //   105:     }
  13, 6,                                     //   109:     case 0xd: {
  OPC_CheckPredicate, 0,                     //   111:      check predicate 0
  OPC_Decode, 201, 6, 2,                     //   113:      decode to REVB_4H using decoder 2
                                             //   113:     }
  14, 6,                                     //   117:     case 0xe: {
  OPC_CheckPredicate, 0,                     //   119:      check predicate 0
  OPC_Decode, 200, 6, 2,                     //   121:      decode to REVB_2W using decoder 2
                                             //   121:     }
  15, 6,                                     //   125:     case 0xf: {
  OPC_CheckPredicate, 0,                     //   127:      check predicate 0
  OPC_Decode, 202, 6, 2,                     //   129:      decode to REVB_D using decoder 2
                                             //   129:     }
  16, 6,                                     //   133:     case 0x10: {
  OPC_CheckPredicate, 0,                     //   135:      check predicate 0
  OPC_Decode, 203, 6, 2,                     //   137:      decode to REVH_2W using decoder 2
                                             //   137:     }
  17, 6,                                     //   141:     case 0x11: {
  OPC_CheckPredicate, 0,                     //   143:      check predicate 0
  OPC_Decode, 204, 6, 2,                     //   145:      decode to REVH_D using decoder 2
                                             //   145:     }
  18, 4,                                     //   149:     case 0x12: {
  OPC_Decode, 161, 4, 2,                     //   151:      decode to BITREV_4B using decoder 2
                                             //   151:     }
  19, 6,                                     //   155:     case 0x13: {
  OPC_CheckPredicate, 0,                     //   157:      check predicate 0
  OPC_Decode, 162, 4, 2,                     //   159:      decode to BITREV_8B using decoder 2
                                             //   159:     }
  20, 4,                                     //   163:     case 0x14: {
  OPC_Decode, 164, 4, 2,                     //   165:      decode to BITREV_W using decoder 2
                                             //   165:     }
  21, 6,                                     //   169:     case 0x15: {
  OPC_CheckPredicate, 0,                     //   171:      check predicate 0
  OPC_Decode, 163, 4, 2,                     //   173:      decode to BITREV_D using decoder 2
                                             //   173:     }
  22, 4,                                     //   177:     case 0x16: {
  OPC_Decode, 206, 4, 2,                     //   179:      decode to EXT_W_H using decoder 2
                                             //   179:     }
  23, 4,                                     //   183:     case 0x17: {
  OPC_Decode, 205, 4, 2,                     //   185:      decode to EXT_W_B using decoder 2
                                             //   185:     }
  24, 4,                                     //   189:     case 0x18: {
  OPC_Decode, 197, 6, 2,                     //   191:      decode to RDTIMEL_W using decoder 2
                                             //   191:     }
  25, 4,                                     //   195:     case 0x19: {
  OPC_Decode, 196, 6, 2,                     //   197:      decode to RDTIMEH_W using decoder 2
                                             //   197:     }
  26, 6,                                     //   201:     case 0x1a: {
  OPC_CheckPredicate, 0,                     //   203:      check predicate 0
  OPC_Decode, 198, 6, 2,                     //   205:      decode to RDTIME_D using decoder 2
                                             //   205:     }
  27, 4,                                     //   209:     case 0x1b: {
  OPC_Decode, 182, 4, 2,                     //   211:      decode to CPUCFG using decoder 2
                                             //   211:     }
  28, 12,                                    //   215:     case 0x1c: {
  OPC_CheckField, 8, 2, 0,                   //   217:      check Inst[9:8] == 0x0
  OPC_CheckField, 0, 5, 0,                   //   221:      check Inst[4:0] == 0x0
  OPC_Decode, 136, 13, 3,                    //   225:      decode to X86MTTOP using decoder 3
                                             //   225:     }
  29, 8,                                     //   229:     case 0x1d: {
  OPC_CheckField, 5, 5, 0,                   //   231:      check Inst[9:5] == 0x0
  OPC_Decode, 134, 13, 4,                    //   235:      decode to X86MFTOP using decoder 4
                                             //   235:     }
  30, 4,                                     //   239:     case 0x1e: {
  OPC_Decode, 224, 6, 2,                     //   241:      decode to SETX86LOOPE using decoder 2
                                             //   241:     }
  31, 0,                                     //   245:     case 0x1f: {
  OPC_Decode, 225, 6, 2,                     //   247:      decode to SETX86LOOPNE using decoder 2
                                             //   247:     }
                                             //   247:     } // switch Inst[14:10]
                                             //   247:    }
  1, 121,                                    //   251:    case 0x1: {
  OPC_SwitchField, 0, 5,                     //   253:     switch Inst[4:0] {
  0, 8,                                      //   256:     case 0x0: {
  OPC_CheckField, 10, 5, 0,                  //   258:      check Inst[14:10] == 0x0
  OPC_Decode, 129, 13, 5,                    //   262:      decode to X86INC_B using decoder 5
                                             //   262:     }
  1, 8,                                      //   266:     case 0x1: {
  OPC_CheckField, 10, 5, 0,                  //   268:      check Inst[14:10] == 0x0
  OPC_Decode, 131, 13, 5,                    //   272:      decode to X86INC_H using decoder 5
                                             //   272:     }
  2, 8,                                      //   276:     case 0x2: {
  OPC_CheckField, 10, 5, 0,                  //   278:      check Inst[14:10] == 0x0
  OPC_Decode, 132, 13, 5,                    //   282:      decode to X86INC_W using decoder 5
                                             //   282:     }
  3, 10,                                     //   286:     case 0x3: {
  OPC_CheckPredicate, 0,                     //   288:      check predicate 0
  OPC_CheckField, 10, 5, 0,                  //   290:      check Inst[14:10] == 0x0
  OPC_Decode, 130, 13, 5,                    //   294:      decode to X86INC_D using decoder 5
                                             //   294:     }
  4, 8,                                      //   298:     case 0x4: {
  OPC_CheckField, 10, 5, 0,                  //   300:      check Inst[14:10] == 0x0
  OPC_Decode, 252, 12, 5,                    //   304:      decode to X86DEC_B using decoder 5
                                             //   304:     }
  5, 8,                                      //   308:     case 0x5: {
  OPC_CheckField, 10, 5, 0,                  //   310:      check Inst[14:10] == 0x0
  OPC_Decode, 254, 12, 5,                    //   314:      decode to X86DEC_H using decoder 5
                                             //   314:     }
  6, 8,                                      //   318:     case 0x6: {
  OPC_CheckField, 10, 5, 0,                  //   320:      check Inst[14:10] == 0x0
  OPC_Decode, 255, 12, 5,                    //   324:      decode to X86DEC_W using decoder 5
                                             //   324:     }
  7, 10,                                     //   328:     case 0x7: {
  OPC_CheckPredicate, 0,                     //   330:      check predicate 0
  OPC_CheckField, 10, 5, 0,                  //   332:      check Inst[14:10] == 0x0
  OPC_Decode, 253, 12, 5,                    //   336:      decode to X86DEC_D using decoder 5
                                             //   336:     }
  8, 15,                                     //   340:     case 0x8: {
  OPC_SwitchField, 5, 10,                    //   342:      switch Inst[14:5] {
  0, 4,                                      //   345:      case 0x0: {
  OPC_Decode, 186, 13, 6,                    //   347:       decode to X86SETTM using decoder 6
                                             //   347:      }
  1, 0,                                      //   351:      case 0x1: {
  OPC_Decode, 250, 12, 6,                    //   353:       decode to X86CLRTM using decoder 6
                                             //   353:      }
                                             //   353:      } // switch Inst[14:5]
                                             //   353:     }
  9, 0,                                      //   357:     case 0x9: {
  OPC_SwitchField, 5, 10,                    //   359:      switch Inst[14:5] {
  0, 4,                                      //   362:      case 0x0: {
  OPC_Decode, 128, 13, 6,                    //   364:       decode to X86INCTOP using decoder 6
                                             //   364:      }
  1, 0,                                      //   368:      case 0x1: {
  OPC_Decode, 251, 12, 6,                    //   370:       decode to X86DECTOP using decoder 6
                                             //   370:      }
                                             //   370:      } // switch Inst[14:5]
                                             //   370:     }
                                             //   370:     } // switch Inst[4:0]
                                             //   370:    }
  2, 10,                                     //   374:    case 0x2: {
  OPC_CheckPredicate, 0,                     //   376:     check predicate 0
  OPC_CheckField, 0, 5, 0,                   //   378:     check Inst[4:0] == 0x0
  OPC_Decode, 153, 4, 7,                     //   382:     decode to ASRTLE_D using decoder 7
                                             //   382:    }
  3, 0,                                      //   386:    case 0x3: {
  OPC_CheckPredicate, 0,                     //   388:     check predicate 0
  OPC_CheckField, 0, 5, 0,                   //   390:     check Inst[4:0] == 0x0
  OPC_Decode, 152, 4, 7,                     //   394:     decode to ASRTGT_D using decoder 7
                                             //   394:    }
                                             //   394:    } // switch Inst[17:15]
                                             //   394:   }
  1, 17,                                     //   398:   case 0x1: {
  OPC_SwitchField, 17, 1,                    //   400:    switch Inst[17] {
  0, 4,                                      //   403:    case 0x0: {
  OPC_Decode, 201, 3, 8,                     //   405:     decode to ALSL_W using decoder 8
                                             //   405:    }
  1, 0,                                      //   409:    case 0x1: {
  OPC_CheckPredicate, 0,                     //   411:     check predicate 0
  OPC_Decode, 202, 3, 8,                     //   413:     decode to ALSL_WU using decoder 8
                                             //   413:    }
                                             //   413:    } // switch Inst[17]
                                             //   413:   }
  2, 8,                                      //   417:   case 0x2: {
  OPC_CheckField, 17, 1, 0,                  //   419:    check Inst[17] == 0x0
  OPC_Decode, 176, 4, 9,                     //   423:    decode to BYTEPICK_W using decoder 9
                                             //   423:   }
  3, 6,                                      //   427:   case 0x3: {
  OPC_CheckPredicate, 0,                     //   429:    check predicate 0
  OPC_Decode, 175, 4, 10,                    //   431:    decode to BYTEPICK_D using decoder 10
                                             //   431:   }
  4, 55,                                     //   435:   case 0x4: {
  OPC_SwitchField, 15, 3,                    //   437:    switch Inst[17:15] {
  0, 4,                                      //   440:    case 0x0: {
  OPC_Decode, 199, 3, 11,                    //   442:     decode to ADD_W using decoder 11
                                             //   442:    }
  1, 6,                                      //   446:    case 0x1: {
  OPC_CheckPredicate, 0,                     //   448:     check predicate 0
  OPC_Decode, 198, 3, 11,                    //   450:     decode to ADD_D using decoder 11
                                             //   450:    }
  2, 4,                                      //   454:    case 0x2: {
  OPC_Decode, 139, 7, 11,                    //   456:     decode to SUB_W using decoder 11
                                             //   456:    }
  3, 6,                                      //   460:    case 0x3: {
  OPC_CheckPredicate, 0,                     //   462:     check predicate 0
  OPC_Decode, 138, 7, 11,                    //   464:     decode to SUB_D using decoder 11
                                             //   464:    }
  4, 4,                                      //   468:    case 0x4: {
  OPC_Decode, 232, 6, 11,                    //   470:     decode to SLT using decoder 11
                                             //   470:    }
  5, 4,                                      //   474:    case 0x5: {
  OPC_Decode, 234, 6, 11,                    //   476:     decode to SLTU using decoder 11
                                             //   476:    }
  6, 4,                                      //   480:    case 0x6: {
  OPC_Decode, 148, 6, 11,                    //   482:     decode to MASKEQZ using decoder 11
                                             //   482:    }
  7, 0,                                      //   486:    case 0x7: {
  OPC_Decode, 149, 6, 11,                    //   488:     decode to MASKNEZ using decoder 11
                                             //   488:    }
                                             //   488:    } // switch Inst[17:15]
                                             //   488:   }
  5, 51,                                     //   492:   case 0x5: {
  OPC_SwitchField, 15, 3,                    //   494:    switch Inst[17:15] {
  0, 4,                                      //   497:    case 0x0: {
  OPC_Decode, 178, 6, 11,                    //   499:     decode to NOR using decoder 11
                                             //   499:    }
  1, 4,                                      //   503:    case 0x1: {
  OPC_Decode, 255, 3, 11,                    //   505:     decode to AND using decoder 11
                                             //   505:    }
  2, 4,                                      //   509:    case 0x2: {
  OPC_Decode, 179, 6, 11,                    //   511:     decode to OR using decoder 11
                                             //   511:    }
  3, 4,                                      //   515:    case 0x3: {
  OPC_Decode, 221, 13, 11,                   //   517:     decode to XOR using decoder 11
                                             //   517:    }
  4, 4,                                      //   521:    case 0x4: {
  OPC_Decode, 181, 6, 11,                    //   523:     decode to ORN using decoder 11
                                             //   523:    }
  5, 4,                                      //   527:    case 0x5: {
  OPC_Decode, 129, 4, 11,                    //   529:     decode to ANDN using decoder 11
                                             //   529:    }
  6, 4,                                      //   533:    case 0x6: {
  OPC_Decode, 231, 6, 11,                    //   535:     decode to SLL_W using decoder 11
                                             //   535:    }
  7, 0,                                      //   539:    case 0x7: {
  OPC_Decode, 243, 6, 11,                    //   541:     decode to SRL_W using decoder 11
                                             //   541:    }
                                             //   541:    } // switch Inst[17:15]
                                             //   541:   }
  6, 59,                                     //   545:   case 0x6: {
  OPC_SwitchField, 15, 3,                    //   547:    switch Inst[17:15] {
  0, 4,                                      //   550:    case 0x0: {
  OPC_Decode, 239, 6, 11,                    //   552:     decode to SRA_W using decoder 11
                                             //   552:    }
  1, 6,                                      //   556:    case 0x1: {
  OPC_CheckPredicate, 0,                     //   558:     check predicate 0
  OPC_Decode, 230, 6, 11,                    //   560:     decode to SLL_D using decoder 11
                                             //   560:    }
  2, 6,                                      //   564:    case 0x2: {
  OPC_CheckPredicate, 0,                     //   566:     check predicate 0
  OPC_Decode, 242, 6, 11,                    //   568:     decode to SRL_D using decoder 11
                                             //   568:    }
  3, 6,                                      //   572:    case 0x3: {
  OPC_CheckPredicate, 0,                     //   574:     check predicate 0
  OPC_Decode, 238, 6, 11,                    //   576:     decode to SRA_D using decoder 11
                                             //   576:    }
  4, 4,                                      //   580:    case 0x4: {
  OPC_Decode, 209, 6, 11,                    //   582:     decode to ROTR_B using decoder 11
                                             //   582:    }
  5, 4,                                      //   586:    case 0x5: {
  OPC_Decode, 211, 6, 11,                    //   588:     decode to ROTR_H using decoder 11
                                             //   588:    }
  6, 4,                                      //   592:    case 0x6: {
  OPC_Decode, 212, 6, 11,                    //   594:     decode to ROTR_W using decoder 11
                                             //   594:    }
  7, 0,                                      //   598:    case 0x7: {
  OPC_CheckPredicate, 0,                     //   600:     check predicate 0
  OPC_Decode, 210, 6, 11,                    //   602:     decode to ROTR_D using decoder 11
                                             //   602:    }
                                             //   602:    } // switch Inst[17:15]
                                             //   602:   }
  7, 61,                                     //   606:   case 0x7: {
  OPC_SwitchField, 15, 3,                    //   608:    switch Inst[17:15] {
  0, 4,                                      //   611:    case 0x0: {
  OPC_Decode, 177, 6, 11,                    //   613:     decode to MUL_W using decoder 11
                                             //   613:    }
  1, 4,                                      //   617:    case 0x1: {
  OPC_Decode, 172, 6, 11,                    //   619:     decode to MULH_W using decoder 11
                                             //   619:    }
  2, 4,                                      //   623:    case 0x2: {
  OPC_Decode, 173, 6, 11,                    //   625:     decode to MULH_WU using decoder 11
                                             //   625:    }
  3, 6,                                      //   629:    case 0x3: {
  OPC_CheckPredicate, 0,                     //   631:     check predicate 0
  OPC_Decode, 176, 6, 11,                    //   633:     decode to MUL_D using decoder 11
                                             //   633:    }
  4, 6,                                      //   637:    case 0x4: {
  OPC_CheckPredicate, 0,                     //   639:     check predicate 0
  OPC_Decode, 170, 6, 11,                    //   641:     decode to MULH_D using decoder 11
                                             //   641:    }
  5, 6,                                      //   645:    case 0x5: {
  OPC_CheckPredicate, 0,                     //   647:     check predicate 0
  OPC_Decode, 171, 6, 11,                    //   649:     decode to MULH_DU using decoder 11
                                             //   649:    }
  6, 6,                                      //   653:    case 0x6: {
  OPC_CheckPredicate, 0,                     //   655:     check predicate 0
  OPC_Decode, 174, 6, 11,                    //   657:     decode to MULW_D_W using decoder 11
                                             //   657:    }
  7, 0,                                      //   661:    case 0x7: {
  OPC_CheckPredicate, 0,                     //   663:     check predicate 0
  OPC_Decode, 175, 6, 11,                    //   665:     decode to MULW_D_WU using decoder 11
                                             //   665:    }
                                             //   665:    } // switch Inst[17:15]
                                             //   665:   }
  8, 59,                                     //   669:   case 0x8: {
  OPC_SwitchField, 15, 3,                    //   671:    switch Inst[17:15] {
  0, 4,                                      //   674:    case 0x0: {
  OPC_Decode, 202, 4, 11,                    //   676:     decode to DIV_W using decoder 11
                                             //   676:    }
  1, 4,                                      //   680:    case 0x1: {
  OPC_Decode, 152, 6, 11,                    //   682:     decode to MOD_W using decoder 11
                                             //   682:    }
  2, 4,                                      //   686:    case 0x2: {
  OPC_Decode, 203, 4, 11,                    //   688:     decode to DIV_WU using decoder 11
                                             //   688:    }
  3, 4,                                      //   692:    case 0x3: {
  OPC_Decode, 153, 6, 11,                    //   694:     decode to MOD_WU using decoder 11
                                             //   694:    }
  4, 6,                                      //   698:    case 0x4: {
  OPC_CheckPredicate, 0,                     //   700:     check predicate 0
  OPC_Decode, 200, 4, 11,                    //   702:     decode to DIV_D using decoder 11
                                             //   702:    }
  5, 6,                                      //   706:    case 0x5: {
  OPC_CheckPredicate, 0,                     //   708:     check predicate 0
  OPC_Decode, 150, 6, 11,                    //   710:     decode to MOD_D using decoder 11
                                             //   710:    }
  6, 6,                                      //   714:    case 0x6: {
  OPC_CheckPredicate, 0,                     //   716:     check predicate 0
  OPC_Decode, 201, 4, 11,                    //   718:     decode to DIV_DU using decoder 11
                                             //   718:    }
  7, 0,                                      //   722:    case 0x7: {
  OPC_CheckPredicate, 0,                     //   724:     check predicate 0
  OPC_Decode, 151, 6, 11,                    //   726:     decode to MOD_DU using decoder 11
                                             //   726:    }
                                             //   726:    } // switch Inst[17:15]
                                             //   726:   }
  9, 67,                                     //   730:   case 0x9: {
  OPC_SwitchField, 15, 3,                    //   732:    switch Inst[17:15] {
  0, 6,                                      //   735:    case 0x0: {
  OPC_CheckPredicate, 0,                     //   737:     check predicate 0
  OPC_Decode, 187, 4, 11,                    //   739:     decode to CRC_W_B_W using decoder 11
                                             //   739:    }
  1, 6,                                      //   743:    case 0x1: {
  OPC_CheckPredicate, 0,                     //   745:     check predicate 0
  OPC_Decode, 189, 4, 11,                    //   747:     decode to CRC_W_H_W using decoder 11
                                             //   747:    }
  2, 6,                                      //   751:    case 0x2: {
  OPC_CheckPredicate, 0,                     //   753:     check predicate 0
  OPC_Decode, 190, 4, 11,                    //   755:     decode to CRC_W_W_W using decoder 11
                                             //   755:    }
  3, 6,                                      //   759:    case 0x3: {
  OPC_CheckPredicate, 0,                     //   761:     check predicate 0
  OPC_Decode, 188, 4, 11,                    //   763:     decode to CRC_W_D_W using decoder 11
                                             //   763:    }
  4, 6,                                      //   767:    case 0x4: {
  OPC_CheckPredicate, 0,                     //   769:     check predicate 0
  OPC_Decode, 183, 4, 11,                    //   771:     decode to CRCC_W_B_W using decoder 11
                                             //   771:    }
  5, 6,                                      //   775:    case 0x5: {
  OPC_CheckPredicate, 0,                     //   777:     check predicate 0
  OPC_Decode, 185, 4, 11,                    //   779:     decode to CRCC_W_H_W using decoder 11
                                             //   779:    }
  6, 6,                                      //   783:    case 0x6: {
  OPC_CheckPredicate, 0,                     //   785:     check predicate 0
  OPC_Decode, 186, 4, 11,                    //   787:     decode to CRCC_W_W_W using decoder 11
                                             //   787:    }
  7, 0,                                      //   791:    case 0x7: {
  OPC_CheckPredicate, 0,                     //   793:     check predicate 0
  OPC_Decode, 184, 4, 11,                    //   795:     decode to CRCC_W_D_W using decoder 11
                                             //   795:    }
                                             //   795:    } // switch Inst[17:15]
                                             //   795:   }
  10, 41,                                    //   799:   case 0xa: {
  OPC_SwitchField, 15, 3,                    //   801:    switch Inst[17:15] {
  2, 4,                                      //   804:    case 0x2: {
  OPC_Decode, 196, 3, 12,                    //   806:     decode to ADDU12I_W using decoder 12
                                             //   806:    }
  3, 6,                                      //   810:    case 0x3: {
  OPC_CheckPredicate, 0,                     //   812:     check predicate 0
  OPC_Decode, 195, 3, 12,                    //   814:     decode to ADDU12I_D using decoder 12
                                             //   814:    }
  4, 4,                                      //   818:    case 0x4: {
  OPC_Decode, 170, 4, 13,                    //   820:     decode to BREAK using decoder 13
                                             //   820:    }
  5, 4,                                      //   824:    case 0x5: {
  OPC_Decode, 199, 4, 13,                    //   826:     decode to DBCL using decoder 13
                                             //   826:    }
  6, 4,                                      //   830:    case 0x6: {
  OPC_Decode, 140, 7, 13,                    //   832:     decode to SYSCALL using decoder 13
                                             //   832:    }
  7, 0,                                      //   836:    case 0x7: {
  OPC_Decode, 224, 5, 13,                    //   838:     decode to HVCL using decoder 13
                                             //   838:    }
                                             //   838:    } // switch Inst[17:15]
                                             //   838:   }
  11, 10,                                    //   842:   case 0xb: {
  OPC_CheckPredicate, 0,                     //   844:    check predicate 0
  OPC_CheckField, 17, 1, 0,                  //   846:    check Inst[17] == 0x0
  OPC_Decode, 200, 3, 8,                     //   850:    decode to ALSL_D using decoder 8
                                             //   850:   }
  12, 55,                                    //   854:   case 0xc: {
  OPC_SwitchField, 15, 3,                    //   856:    switch Inst[17:15] {
  0, 4,                                      //   859:    case 0x0: {
  OPC_Decode, 189, 3, 11,                    //   861:     decode to ADC_B using decoder 11
                                             //   861:    }
  1, 4,                                      //   865:    case 0x1: {
  OPC_Decode, 191, 3, 11,                    //   867:     decode to ADC_H using decoder 11
                                             //   867:    }
  2, 4,                                      //   871:    case 0x2: {
  OPC_Decode, 192, 3, 11,                    //   873:     decode to ADC_W using decoder 11
                                             //   873:    }
  3, 6,                                      //   877:    case 0x3: {
  OPC_CheckPredicate, 0,                     //   879:     check predicate 0
  OPC_Decode, 190, 3, 11,                    //   881:     decode to ADC_D using decoder 11
                                             //   881:    }
  4, 4,                                      //   885:    case 0x4: {
  OPC_Decode, 213, 6, 11,                    //   887:     decode to SBC_B using decoder 11
                                             //   887:    }
  5, 4,                                      //   891:    case 0x5: {
  OPC_Decode, 215, 6, 11,                    //   893:     decode to SBC_H using decoder 11
                                             //   893:    }
  6, 4,                                      //   897:    case 0x6: {
  OPC_Decode, 216, 6, 11,                    //   899:     decode to SBC_W using decoder 11
                                             //   899:    }
  7, 0,                                      //   903:    case 0x7: {
  OPC_CheckPredicate, 0,                     //   905:     check predicate 0
  OPC_Decode, 214, 6, 11,                    //   907:     decode to SBC_D using decoder 11
                                             //   907:    }
                                             //   907:    } // switch Inst[17:15]
                                             //   907:   }
  13, 84,                                    //   911:   case 0xd: {
  OPC_SwitchField, 15, 3,                    //   913:    switch Inst[17:15] {
  0, 4,                                      //   916:    case 0x0: {
  OPC_Decode, 192, 6, 11,                    //   918:     decode to RCR_B using decoder 11
                                             //   918:    }
  1, 4,                                      //   922:    case 0x1: {
  OPC_Decode, 194, 6, 11,                    //   924:     decode to RCR_H using decoder 11
                                             //   924:    }
  2, 4,                                      //   928:    case 0x2: {
  OPC_Decode, 195, 6, 11,                    //   930:     decode to RCR_W using decoder 11
                                             //   930:    }
  3, 6,                                      //   934:    case 0x3: {
  OPC_CheckPredicate, 0,                     //   936:     check predicate 0
  OPC_Decode, 193, 6, 11,                    //   938:     decode to RCR_D using decoder 11
                                             //   938:    }
  4, 8,                                      //   942:    case 0x4: {
  OPC_CheckField, 14, 1, 1,                  //   944:     check Inst[14] == 0x1
  OPC_Decode, 134, 4, 14,                    //   948:     decode to ARMMOVE using decoder 14
                                             //   948:    }
  5, 23,                                     //   952:    case 0x5: {
  OPC_SwitchField, 14, 1,                    //   954:     switch Inst[14] {
  0, 8,                                      //   957:     case 0x0: {
  OPC_CheckField, 5, 5, 0,                   //   959:      check Inst[9:5] == 0x0
  OPC_Decode, 223, 6, 15,                    //   963:      decode to SETX86J using decoder 15
                                             //   963:     }
  1, 0,                                      //   967:     case 0x1: {
  OPC_CheckField, 5, 5, 0,                   //   969:      check Inst[9:5] == 0x0
  OPC_Decode, 222, 6, 15,                    //   973:      decode to SETARMJ using decoder 15
                                             //   973:     }
                                             //   973:     } // switch Inst[14]
                                             //   973:    }
  6, 8,                                      //   977:    case 0x6: {
  OPC_CheckField, 4, 1, 1,                   //   979:     check Inst[4] == 0x1
  OPC_Decode, 131, 4, 16,                    //   983:     decode to ARMADD_W using decoder 16
                                             //   983:    }
  7, 0,                                      //   987:    case 0x7: {
  OPC_CheckField, 4, 1, 1,                   //   989:     check Inst[4] == 0x1
  OPC_Decode, 150, 4, 16,                    //   993:     decode to ARMSUB_W using decoder 16
                                             //   993:    }
                                             //   993:    } // switch Inst[17:15]
                                             //   993:   }
  14, 83,                                    //   997:   case 0xe: {
  OPC_SwitchField, 15, 3,                    //   999:    switch Inst[17:15] {
  0, 8,                                      //  1002:    case 0x0: {
  OPC_CheckField, 4, 1, 1,                   //  1004:     check Inst[4] == 0x1
  OPC_Decode, 130, 4, 16,                    //  1008:     decode to ARMADC_W using decoder 16
                                             //  1008:    }
  1, 8,                                      //  1012:    case 0x1: {
  OPC_CheckField, 4, 1, 1,                   //  1014:     check Inst[4] == 0x1
  OPC_Decode, 143, 4, 16,                    //  1018:     decode to ARMSBC_W using decoder 16
                                             //  1018:    }
  2, 8,                                      //  1022:    case 0x2: {
  OPC_CheckField, 4, 1, 1,                   //  1024:     check Inst[4] == 0x1
  OPC_Decode, 132, 4, 16,                    //  1028:     decode to ARMAND_W using decoder 16
                                             //  1028:    }
  3, 8,                                      //  1032:    case 0x3: {
  OPC_CheckField, 4, 1, 1,                   //  1034:     check Inst[4] == 0x1
  OPC_Decode, 139, 4, 16,                    //  1038:     decode to ARMOR_W using decoder 16
                                             //  1038:    }
  4, 8,                                      //  1042:    case 0x4: {
  OPC_CheckField, 4, 1, 1,                   //  1044:     check Inst[4] == 0x1
  OPC_Decode, 151, 4, 16,                    //  1048:     decode to ARMXOR_W using decoder 16
                                             //  1048:    }
  5, 8,                                      //  1052:    case 0x5: {
  OPC_CheckField, 4, 1, 1,                   //  1054:     check Inst[4] == 0x1
  OPC_Decode, 145, 4, 16,                    //  1058:     decode to ARMSLL_W using decoder 16
                                             //  1058:    }
  6, 8,                                      //  1062:    case 0x6: {
  OPC_CheckField, 4, 1, 1,                   //  1064:     check Inst[4] == 0x1
  OPC_Decode, 149, 4, 16,                    //  1068:     decode to ARMSRL_W using decoder 16
                                             //  1068:    }
  7, 0,                                      //  1072:    case 0x7: {
  OPC_CheckField, 4, 1, 1,                   //  1074:     check Inst[4] == 0x1
  OPC_Decode, 147, 4, 16,                    //  1078:     decode to ARMSRA_W using decoder 16
                                             //  1078:    }
                                             //  1078:    } // switch Inst[17:15]
                                             //  1078:   }
  15, 0,                                     //  1082:   case 0xf: {
  OPC_SwitchField, 15, 3,                    //  1084:    switch Inst[17:15] {
  0, 8,                                      //  1087:    case 0x0: {
  OPC_CheckField, 4, 1, 1,                   //  1089:     check Inst[4] == 0x1
  OPC_Decode, 141, 4, 16,                    //  1093:     decode to ARMROTR_W using decoder 16
                                             //  1093:    }
  1, 8,                                      //  1097:    case 0x1: {
  OPC_CheckField, 4, 1, 1,                   //  1099:     check Inst[4] == 0x1
  OPC_Decode, 144, 4, 17,                    //  1103:     decode to ARMSLLI_W using decoder 17
                                             //  1103:    }
  2, 8,                                      //  1107:    case 0x2: {
  OPC_CheckField, 4, 1, 1,                   //  1109:     check Inst[4] == 0x1
  OPC_Decode, 148, 4, 17,                    //  1113:     decode to ARMSRLI_W using decoder 17
                                             //  1113:    }
  3, 8,                                      //  1117:    case 0x3: {
  OPC_CheckField, 4, 1, 1,                   //  1119:     check Inst[4] == 0x1
  OPC_Decode, 146, 4, 17,                    //  1123:     decode to ARMSRAI_W using decoder 17
                                             //  1123:    }
  4, 8,                                      //  1127:    case 0x4: {
  OPC_CheckField, 4, 1, 1,                   //  1129:     check Inst[4] == 0x1
  OPC_Decode, 140, 4, 17,                    //  1133:     decode to ARMROTRI_W using decoder 17
                                             //  1133:    }
  5, 57,                                     //  1137:    case 0x5: {
  OPC_SwitchField, 0, 5,                     //  1139:     switch Inst[4:0] {
  0, 4,                                      //  1142:     case 0x0: {
  OPC_Decode, 137, 13, 7,                    //  1144:      decode to X86MUL_B using decoder 7
                                             //  1144:     }
  1, 4,                                      //  1148:     case 0x1: {
  OPC_Decode, 141, 13, 7,                    //  1150:      decode to X86MUL_H using decoder 7
                                             //  1150:     }
  2, 4,                                      //  1154:     case 0x2: {
  OPC_Decode, 143, 13, 7,                    //  1156:      decode to X86MUL_W using decoder 7
                                             //  1156:     }
  3, 6,                                      //  1160:     case 0x3: {
  OPC_CheckPredicate, 0,                     //  1162:      check predicate 0
  OPC_Decode, 139, 13, 7,                    //  1164:      decode to X86MUL_D using decoder 7
                                             //  1164:     }
  4, 4,                                      //  1168:     case 0x4: {
  OPC_Decode, 138, 13, 7,                    //  1170:      decode to X86MUL_BU using decoder 7
                                             //  1170:     }
  5, 4,                                      //  1174:     case 0x5: {
  OPC_Decode, 142, 13, 7,                    //  1176:      decode to X86MUL_HU using decoder 7
                                             //  1176:     }
  6, 6,                                      //  1180:     case 0x6: {
  OPC_CheckPredicate, 0,                     //  1182:      check predicate 0
  OPC_Decode, 144, 13, 7,                    //  1184:      decode to X86MUL_WU using decoder 7
                                             //  1184:     }
  7, 0,                                      //  1188:     case 0x7: {
  OPC_CheckPredicate, 0,                     //  1190:      check predicate 0
  OPC_Decode, 140, 13, 7,                    //  1192:      decode to X86MUL_DU using decoder 7
                                             //  1192:     }
                                             //  1192:     } // switch Inst[4:0]
                                             //  1192:    }
  6, 217, 1,                                 //  1196:    case 0x6: {
  OPC_SwitchField, 0, 5,                     //  1199:     switch Inst[4:0] {
  0, 6,                                      //  1202:     case 0x0: {
  OPC_CheckPredicate, 0,                     //  1204:      check predicate 0
  OPC_Decode, 245, 12, 7,                    //  1206:      decode to X86ADD_WU using decoder 7
                                             //  1206:     }
  1, 6,                                      //  1210:     case 0x1: {
  OPC_CheckPredicate, 0,                     //  1212:      check predicate 0
  OPC_Decode, 242, 12, 7,                    //  1214:      decode to X86ADD_DU using decoder 7
                                             //  1214:     }
  2, 6,                                      //  1218:     case 0x2: {
  OPC_CheckPredicate, 0,                     //  1220:      check predicate 0
  OPC_Decode, 216, 13, 7,                    //  1222:      decode to X86SUB_WU using decoder 7
                                             //  1222:     }
  3, 6,                                      //  1226:     case 0x3: {
  OPC_CheckPredicate, 0,                     //  1228:      check predicate 0
  OPC_Decode, 213, 13, 7,                    //  1230:      decode to X86SUB_DU using decoder 7
                                             //  1230:     }
  4, 4,                                      //  1234:     case 0x4: {
  OPC_Decode, 240, 12, 7,                    //  1236:      decode to X86ADD_B using decoder 7
                                             //  1236:     }
  5, 4,                                      //  1240:     case 0x5: {
  OPC_Decode, 243, 12, 7,                    //  1242:      decode to X86ADD_H using decoder 7
                                             //  1242:     }
  6, 4,                                      //  1246:     case 0x6: {
  OPC_Decode, 244, 12, 7,                    //  1248:      decode to X86ADD_W using decoder 7
                                             //  1248:     }
  7, 6,                                      //  1252:     case 0x7: {
  OPC_CheckPredicate, 0,                     //  1254:      check predicate 0
  OPC_Decode, 241, 12, 7,                    //  1256:      decode to X86ADD_D using decoder 7
                                             //  1256:     }
  8, 4,                                      //  1260:     case 0x8: {
  OPC_Decode, 211, 13, 7,                    //  1262:      decode to X86SUB_B using decoder 7
                                             //  1262:     }
  9, 4,                                      //  1266:     case 0x9: {
  OPC_Decode, 214, 13, 7,                    //  1268:      decode to X86SUB_H using decoder 7
                                             //  1268:     }
  10, 4,                                     //  1272:     case 0xa: {
  OPC_Decode, 215, 13, 7,                    //  1274:      decode to X86SUB_W using decoder 7
                                             //  1274:     }
  11, 6,                                     //  1278:     case 0xb: {
  OPC_CheckPredicate, 0,                     //  1280:      check predicate 0
  OPC_Decode, 212, 13, 7,                    //  1282:      decode to X86SUB_D using decoder 7
                                             //  1282:     }
  12, 4,                                     //  1286:     case 0xc: {
  OPC_Decode, 236, 12, 7,                    //  1288:      decode to X86ADC_B using decoder 7
                                             //  1288:     }
  13, 4,                                     //  1292:     case 0xd: {
  OPC_Decode, 238, 12, 7,                    //  1294:      decode to X86ADC_H using decoder 7
                                             //  1294:     }
  14, 4,                                     //  1298:     case 0xe: {
  OPC_Decode, 239, 12, 7,                    //  1300:      decode to X86ADC_W using decoder 7
                                             //  1300:     }
  15, 6,                                     //  1304:     case 0xf: {
  OPC_CheckPredicate, 0,                     //  1306:      check predicate 0
  OPC_Decode, 237, 12, 7,                    //  1308:      decode to X86ADC_D using decoder 7
                                             //  1308:     }
  16, 4,                                     //  1312:     case 0x10: {
  OPC_Decode, 181, 13, 7,                    //  1314:      decode to X86SBC_B using decoder 7
                                             //  1314:     }
  17, 4,                                     //  1318:     case 0x11: {
  OPC_Decode, 183, 13, 7,                    //  1320:      decode to X86SBC_H using decoder 7
                                             //  1320:     }
  18, 4,                                     //  1324:     case 0x12: {
  OPC_Decode, 184, 13, 7,                    //  1326:      decode to X86SBC_W using decoder 7
                                             //  1326:     }
  19, 6,                                     //  1330:     case 0x13: {
  OPC_CheckPredicate, 0,                     //  1332:      check predicate 0
  OPC_Decode, 182, 13, 7,                    //  1334:      decode to X86SBC_D using decoder 7
                                             //  1334:     }
  20, 4,                                     //  1338:     case 0x14: {
  OPC_Decode, 191, 13, 7,                    //  1340:      decode to X86SLL_B using decoder 7
                                             //  1340:     }
  21, 4,                                     //  1344:     case 0x15: {
  OPC_Decode, 193, 13, 7,                    //  1346:      decode to X86SLL_H using decoder 7
                                             //  1346:     }
  22, 4,                                     //  1350:     case 0x16: {
  OPC_Decode, 194, 13, 7,                    //  1352:      decode to X86SLL_W using decoder 7
                                             //  1352:     }
  23, 6,                                     //  1356:     case 0x17: {
  OPC_CheckPredicate, 0,                     //  1358:      check predicate 0
  OPC_Decode, 192, 13, 7,                    //  1360:      decode to X86SLL_D using decoder 7
                                             //  1360:     }
  24, 4,                                     //  1364:     case 0x18: {
  OPC_Decode, 207, 13, 7,                    //  1366:      decode to X86SRL_B using decoder 7
                                             //  1366:     }
  25, 4,                                     //  1370:     case 0x19: {
  OPC_Decode, 209, 13, 7,                    //  1372:      decode to X86SRL_H using decoder 7
                                             //  1372:     }
  26, 4,                                     //  1376:     case 0x1a: {
  OPC_Decode, 210, 13, 7,                    //  1378:      decode to X86SRL_W using decoder 7
                                             //  1378:     }
  27, 6,                                     //  1382:     case 0x1b: {
  OPC_CheckPredicate, 0,                     //  1384:      check predicate 0
  OPC_Decode, 208, 13, 7,                    //  1386:      decode to X86SRL_D using decoder 7
                                             //  1386:     }
  28, 4,                                     //  1390:     case 0x1c: {
  OPC_Decode, 199, 13, 7,                    //  1392:      decode to X86SRA_B using decoder 7
                                             //  1392:     }
  29, 4,                                     //  1396:     case 0x1d: {
  OPC_Decode, 201, 13, 7,                    //  1398:      decode to X86SRA_H using decoder 7
                                             //  1398:     }
  30, 4,                                     //  1402:     case 0x1e: {
  OPC_Decode, 202, 13, 7,                    //  1404:      decode to X86SRA_W using decoder 7
                                             //  1404:     }
  31, 0,                                     //  1408:     case 0x1f: {
  OPC_CheckPredicate, 0,                     //  1410:      check predicate 0
  OPC_Decode, 200, 13, 7,                    //  1412:      decode to X86SRA_D using decoder 7
                                             //  1412:     }
                                             //  1412:     } // switch Inst[4:0]
                                             //  1412:    }
  7, 0,                                      //  1416:    case 0x7: {
  OPC_SwitchField, 0, 5,                     //  1418:     switch Inst[4:0] {
  0, 4,                                      //  1421:     case 0x0: {
  OPC_Decode, 177, 13, 7,                    //  1423:      decode to X86ROTR_B using decoder 7
                                             //  1423:     }
  1, 4,                                      //  1427:     case 0x1: {
  OPC_Decode, 179, 13, 7,                    //  1429:      decode to X86ROTR_H using decoder 7
                                             //  1429:     }
  2, 6,                                      //  1433:     case 0x2: {
  OPC_CheckPredicate, 0,                     //  1435:      check predicate 0
  OPC_Decode, 178, 13, 7,                    //  1437:      decode to X86ROTR_D using decoder 7
                                             //  1437:     }
  3, 4,                                      //  1441:     case 0x3: {
  OPC_Decode, 180, 13, 7,                    //  1443:      decode to X86ROTR_W using decoder 7
                                             //  1443:     }
  4, 4,                                      //  1447:     case 0x4: {
  OPC_Decode, 169, 13, 7,                    //  1449:      decode to X86ROTL_B using decoder 7
                                             //  1449:     }
  5, 4,                                      //  1453:     case 0x5: {
  OPC_Decode, 171, 13, 7,                    //  1455:      decode to X86ROTL_H using decoder 7
                                             //  1455:     }
  6, 4,                                      //  1459:     case 0x6: {
  OPC_Decode, 172, 13, 7,                    //  1461:      decode to X86ROTL_W using decoder 7
                                             //  1461:     }
  7, 6,                                      //  1465:     case 0x7: {
  OPC_CheckPredicate, 0,                     //  1467:      check predicate 0
  OPC_Decode, 170, 13, 7,                    //  1469:      decode to X86ROTL_D using decoder 7
                                             //  1469:     }
  8, 4,                                      //  1473:     case 0x8: {
  OPC_Decode, 161, 13, 7,                    //  1475:      decode to X86RCR_B using decoder 7
                                             //  1475:     }
  9, 4,                                      //  1479:     case 0x9: {
  OPC_Decode, 163, 13, 7,                    //  1481:      decode to X86RCR_H using decoder 7
                                             //  1481:     }
  10, 4,                                     //  1485:     case 0xa: {
  OPC_Decode, 164, 13, 7,                    //  1487:      decode to X86RCR_W using decoder 7
                                             //  1487:     }
  11, 6,                                     //  1491:     case 0xb: {
  OPC_CheckPredicate, 0,                     //  1493:      check predicate 0
  OPC_Decode, 162, 13, 7,                    //  1495:      decode to X86RCR_D using decoder 7
                                             //  1495:     }
  12, 4,                                     //  1499:     case 0xc: {
  OPC_Decode, 153, 13, 7,                    //  1501:      decode to X86RCL_B using decoder 7
                                             //  1501:     }
  13, 4,                                     //  1505:     case 0xd: {
  OPC_Decode, 155, 13, 7,                    //  1507:      decode to X86RCL_H using decoder 7
                                             //  1507:     }
  14, 4,                                     //  1511:     case 0xe: {
  OPC_Decode, 156, 13, 7,                    //  1513:      decode to X86RCL_W using decoder 7
                                             //  1513:     }
  15, 6,                                     //  1517:     case 0xf: {
  OPC_CheckPredicate, 0,                     //  1519:      check predicate 0
  OPC_Decode, 154, 13, 7,                    //  1521:      decode to X86RCL_D using decoder 7
                                             //  1521:     }
  16, 4,                                     //  1525:     case 0x10: {
  OPC_Decode, 246, 12, 7,                    //  1527:      decode to X86AND_B using decoder 7
                                             //  1527:     }
  17, 4,                                     //  1531:     case 0x11: {
  OPC_Decode, 248, 12, 7,                    //  1533:      decode to X86AND_H using decoder 7
                                             //  1533:     }
  18, 4,                                     //  1537:     case 0x12: {
  OPC_Decode, 249, 12, 7,                    //  1539:      decode to X86AND_W using decoder 7
                                             //  1539:     }
  19, 6,                                     //  1543:     case 0x13: {
  OPC_CheckPredicate, 0,                     //  1545:      check predicate 0
  OPC_Decode, 247, 12, 7,                    //  1547:      decode to X86AND_D using decoder 7
                                             //  1547:     }
  20, 4,                                     //  1551:     case 0x14: {
  OPC_Decode, 145, 13, 7,                    //  1553:      decode to X86OR_B using decoder 7
                                             //  1553:     }
  21, 4,                                     //  1557:     case 0x15: {
  OPC_Decode, 147, 13, 7,                    //  1559:      decode to X86OR_H using decoder 7
                                             //  1559:     }
  22, 4,                                     //  1563:     case 0x16: {
  OPC_Decode, 148, 13, 7,                    //  1565:      decode to X86OR_W using decoder 7
                                             //  1565:     }
  23, 6,                                     //  1569:     case 0x17: {
  OPC_CheckPredicate, 0,                     //  1571:      check predicate 0
  OPC_Decode, 146, 13, 7,                    //  1573:      decode to X86OR_D using decoder 7
                                             //  1573:     }
  24, 4,                                     //  1577:     case 0x18: {
  OPC_Decode, 217, 13, 7,                    //  1579:      decode to X86XOR_B using decoder 7
                                             //  1579:     }
  25, 4,                                     //  1583:     case 0x19: {
  OPC_Decode, 219, 13, 7,                    //  1585:      decode to X86XOR_H using decoder 7
                                             //  1585:     }
  26, 4,                                     //  1589:     case 0x1a: {
  OPC_Decode, 220, 13, 7,                    //  1591:      decode to X86XOR_W using decoder 7
                                             //  1591:     }
  27, 6,                                     //  1595:     case 0x1b: {
  OPC_CheckPredicate, 0,                     //  1597:      check predicate 0
  OPC_Decode, 218, 13, 7,                    //  1599:      decode to X86XOR_D using decoder 7
                                             //  1599:     }
  28, 8,                                     //  1603:     case 0x1c: {
  OPC_CheckField, 14, 1, 1,                  //  1605:      check Inst[14] == 0x1
  OPC_Decode, 138, 4, 18,                    //  1609:      decode to ARMNOT_W using decoder 18
                                             //  1609:     }
  29, 8,                                     //  1613:     case 0x1d: {
  OPC_CheckField, 14, 1, 1,                  //  1615:      check Inst[14] == 0x1
  OPC_Decode, 136, 4, 18,                    //  1619:      decode to ARMMOV_W using decoder 18
                                             //  1619:     }
  30, 10,                                    //  1623:     case 0x1e: {
  OPC_CheckPredicate, 0,                     //  1625:      check predicate 0
  OPC_CheckField, 14, 1, 1,                  //  1627:      check Inst[14] == 0x1
  OPC_Decode, 135, 4, 18,                    //  1631:      decode to ARMMOV_D using decoder 18
                                             //  1631:     }
  31, 0,                                     //  1635:     case 0x1f: {
  OPC_CheckField, 14, 1, 1,                  //  1637:      check Inst[14] == 0x1
  OPC_Decode, 142, 4, 18,                    //  1641:      decode to ARMRRX_W using decoder 18
                                             //  1641:     }
                                             //  1641:     } // switch Inst[4:0]
                                             //  1641:    }
                                             //  1641:    } // switch Inst[17:15]
                                             //  1641:   }
                                             //  1641:   } // switch Inst[21:18]
                                             //  1641:  }
  1, 136, 4,                                 //  1645:  case 0x1: {
  OPC_SwitchField, 21, 1,                    //  1648:   switch Inst[21] {
  0, 241, 3,                                 //  1651:   case 0x0: {
  OPC_SwitchField, 18, 3,                    //  1654:    switch Inst[20:18] {
  0, 21,                                     //  1657:    case 0x0: {
  OPC_SwitchField, 16, 2,                    //  1659:     switch Inst[17:16] {
  0, 8,                                      //  1662:     case 0x0: {
  OPC_CheckField, 15, 1, 1,                  //  1664:      check Inst[15] == 0x1
  OPC_Decode, 229, 6, 19,                    //  1668:      decode to SLLI_W using decoder 19
                                             //  1668:     }
  1, 0,                                      //  1672:     case 0x1: {
  OPC_CheckPredicate, 0,                     //  1674:      check predicate 0
  OPC_Decode, 228, 6, 20,                    //  1676:      decode to SLLI_D using decoder 20
                                             //  1676:     }
                                             //  1676:     } // switch Inst[17:16]
                                             //  1676:    }
  1, 21,                                     //  1680:    case 0x1: {
  OPC_SwitchField, 16, 2,                    //  1682:     switch Inst[17:16] {
  0, 8,                                      //  1685:     case 0x0: {
  OPC_CheckField, 15, 1, 1,                  //  1687:      check Inst[15] == 0x1
  OPC_Decode, 241, 6, 19,                    //  1691:      decode to SRLI_W using decoder 19
                                             //  1691:     }
  1, 0,                                      //  1695:     case 0x1: {
  OPC_CheckPredicate, 0,                     //  1697:      check predicate 0
  OPC_Decode, 240, 6, 20,                    //  1699:      decode to SRLI_D using decoder 20
                                             //  1699:     }
                                             //  1699:     } // switch Inst[17:16]
                                             //  1699:    }
  2, 21,                                     //  1703:    case 0x2: {
  OPC_SwitchField, 16, 2,                    //  1705:     switch Inst[17:16] {
  0, 8,                                      //  1708:     case 0x0: {
  OPC_CheckField, 15, 1, 1,                  //  1710:      check Inst[15] == 0x1
  OPC_Decode, 237, 6, 19,                    //  1714:      decode to SRAI_W using decoder 19
                                             //  1714:     }
  1, 0,                                      //  1718:     case 0x1: {
  OPC_CheckPredicate, 0,                     //  1720:      check predicate 0
  OPC_Decode, 236, 6, 20,                    //  1722:      decode to SRAI_D using decoder 20
                                             //  1722:     }
                                             //  1722:     } // switch Inst[17:16]
                                             //  1722:    }
  3, 43,                                     //  1726:    case 0x3: {
  OPC_SwitchField, 16, 2,                    //  1728:     switch Inst[17:16] {
  0, 30,                                     //  1731:     case 0x0: {
  OPC_SwitchField, 15, 1,                    //  1733:      switch Inst[15] {
  0, 19,                                     //  1736:      case 0x0: {
  OPC_SwitchField, 14, 1,                    //  1738:       switch Inst[14] {
  0, 8,                                      //  1741:       case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  1743:        check Inst[13] == 0x1
  OPC_Decode, 205, 6, 21,                    //  1747:        decode to ROTRI_B using decoder 21
                                             //  1747:       }
  1, 0,                                      //  1751:       case 0x1: {
  OPC_Decode, 207, 6, 14,                    //  1753:        decode to ROTRI_H using decoder 14
                                             //  1753:       }
                                             //  1753:       } // switch Inst[14]
                                             //  1753:      }
  1, 0,                                      //  1757:      case 0x1: {
  OPC_Decode, 208, 6, 19,                    //  1759:       decode to ROTRI_W using decoder 19
                                             //  1759:      }
                                             //  1759:      } // switch Inst[15]
                                             //  1759:     }
  1, 0,                                      //  1763:     case 0x1: {
  OPC_CheckPredicate, 0,                     //  1765:      check predicate 0
  OPC_Decode, 206, 6, 20,                    //  1767:      decode to ROTRI_D using decoder 20
                                             //  1767:     }
                                             //  1767:     } // switch Inst[17:16]
                                             //  1767:    }
  4, 43,                                     //  1771:    case 0x4: {
  OPC_SwitchField, 16, 2,                    //  1773:     switch Inst[17:16] {
  0, 30,                                     //  1776:     case 0x0: {
  OPC_SwitchField, 15, 1,                    //  1778:      switch Inst[15] {
  0, 19,                                     //  1781:      case 0x0: {
  OPC_SwitchField, 14, 1,                    //  1783:       switch Inst[14] {
  0, 8,                                      //  1786:       case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  1788:        check Inst[13] == 0x1
  OPC_Decode, 188, 6, 21,                    //  1792:        decode to RCRI_B using decoder 21
                                             //  1792:       }
  1, 0,                                      //  1796:       case 0x1: {
  OPC_Decode, 190, 6, 14,                    //  1798:        decode to RCRI_H using decoder 14
                                             //  1798:       }
                                             //  1798:       } // switch Inst[14]
                                             //  1798:      }
  1, 0,                                      //  1802:      case 0x1: {
  OPC_Decode, 191, 6, 19,                    //  1804:       decode to RCRI_W using decoder 19
                                             //  1804:      }
                                             //  1804:      } // switch Inst[15]
                                             //  1804:     }
  1, 0,                                      //  1808:     case 0x1: {
  OPC_CheckPredicate, 0,                     //  1810:      check predicate 0
  OPC_Decode, 189, 6, 20,                    //  1812:      decode to RCRI_D using decoder 20
                                             //  1812:     }
                                             //  1812:     } // switch Inst[17:16]
                                             //  1812:    }
  5, 169, 2,                                 //  1816:    case 0x5: {
  OPC_SwitchField, 0, 5,                     //  1819:     switch Inst[4:0] {
  0, 8,                                      //  1822:     case 0x0: {
  OPC_CheckField, 13, 5, 1,                  //  1824:      check Inst[17:13] == 0x1
  OPC_Decode, 187, 13, 22,                   //  1828:      decode to X86SLLI_B using decoder 22
                                             //  1828:     }
  1, 8,                                      //  1832:     case 0x1: {
  OPC_CheckField, 14, 4, 1,                  //  1834:      check Inst[17:14] == 0x1
  OPC_Decode, 189, 13, 18,                   //  1838:      decode to X86SLLI_H using decoder 18
                                             //  1838:     }
  2, 8,                                      //  1842:     case 0x2: {
  OPC_CheckField, 15, 3, 1,                  //  1844:      check Inst[17:15] == 0x1
  OPC_Decode, 190, 13, 23,                   //  1848:      decode to X86SLLI_W using decoder 23
                                             //  1848:     }
  3, 10,                                     //  1852:     case 0x3: {
  OPC_CheckPredicate, 0,                     //  1854:      check predicate 0
  OPC_CheckField, 16, 2, 1,                  //  1856:      check Inst[17:16] == 0x1
  OPC_Decode, 188, 13, 24,                   //  1860:      decode to X86SLLI_D using decoder 24
                                             //  1860:     }
  4, 8,                                      //  1864:     case 0x4: {
  OPC_CheckField, 13, 5, 1,                  //  1866:      check Inst[17:13] == 0x1
  OPC_Decode, 203, 13, 22,                   //  1870:      decode to X86SRLI_B using decoder 22
                                             //  1870:     }
  5, 8,                                      //  1874:     case 0x5: {
  OPC_CheckField, 14, 4, 1,                  //  1876:      check Inst[17:14] == 0x1
  OPC_Decode, 205, 13, 18,                   //  1880:      decode to X86SRLI_H using decoder 18
                                             //  1880:     }
  6, 8,                                      //  1884:     case 0x6: {
  OPC_CheckField, 15, 3, 1,                  //  1886:      check Inst[17:15] == 0x1
  OPC_Decode, 206, 13, 23,                   //  1890:      decode to X86SRLI_W using decoder 23
                                             //  1890:     }
  7, 10,                                     //  1894:     case 0x7: {
  OPC_CheckPredicate, 0,                     //  1896:      check predicate 0
  OPC_CheckField, 16, 2, 1,                  //  1898:      check Inst[17:16] == 0x1
  OPC_Decode, 204, 13, 24,                   //  1902:      decode to X86SRLI_D using decoder 24
                                             //  1902:     }
  8, 8,                                      //  1906:     case 0x8: {
  OPC_CheckField, 13, 5, 1,                  //  1908:      check Inst[17:13] == 0x1
  OPC_Decode, 195, 13, 22,                   //  1912:      decode to X86SRAI_B using decoder 22
                                             //  1912:     }
  9, 8,                                      //  1916:     case 0x9: {
  OPC_CheckField, 14, 4, 1,                  //  1918:      check Inst[17:14] == 0x1
  OPC_Decode, 197, 13, 18,                   //  1922:      decode to X86SRAI_H using decoder 18
                                             //  1922:     }
  10, 8,                                     //  1926:     case 0xa: {
  OPC_CheckField, 15, 3, 1,                  //  1928:      check Inst[17:15] == 0x1
  OPC_Decode, 198, 13, 23,                   //  1932:      decode to X86SRAI_W using decoder 23
                                             //  1932:     }
  11, 10,                                    //  1936:     case 0xb: {
  OPC_CheckPredicate, 0,                     //  1938:      check predicate 0
  OPC_CheckField, 16, 2, 1,                  //  1940:      check Inst[17:16] == 0x1
  OPC_Decode, 196, 13, 24,                   //  1944:      decode to X86SRAI_D using decoder 24
                                             //  1944:     }
  12, 8,                                     //  1948:     case 0xc: {
  OPC_CheckField, 13, 5, 1,                  //  1950:      check Inst[17:13] == 0x1
  OPC_Decode, 173, 13, 22,                   //  1954:      decode to X86ROTRI_B using decoder 22
                                             //  1954:     }
  13, 8,                                     //  1958:     case 0xd: {
  OPC_CheckField, 14, 4, 1,                  //  1960:      check Inst[17:14] == 0x1
  OPC_Decode, 175, 13, 18,                   //  1964:      decode to X86ROTRI_H using decoder 18
                                             //  1964:     }
  14, 8,                                     //  1968:     case 0xe: {
  OPC_CheckField, 15, 3, 1,                  //  1970:      check Inst[17:15] == 0x1
  OPC_Decode, 176, 13, 23,                   //  1974:      decode to X86ROTRI_W using decoder 23
                                             //  1974:     }
  15, 10,                                    //  1978:     case 0xf: {
  OPC_CheckPredicate, 0,                     //  1980:      check predicate 0
  OPC_CheckField, 16, 2, 1,                  //  1982:      check Inst[17:16] == 0x1
  OPC_Decode, 174, 13, 24,                   //  1986:      decode to X86ROTRI_D using decoder 24
                                             //  1986:     }
  16, 8,                                     //  1990:     case 0x10: {
  OPC_CheckField, 13, 5, 1,                  //  1992:      check Inst[17:13] == 0x1
  OPC_Decode, 157, 13, 22,                   //  1996:      decode to X86RCRI_B using decoder 22
                                             //  1996:     }
  17, 8,                                     //  2000:     case 0x11: {
  OPC_CheckField, 14, 4, 1,                  //  2002:      check Inst[17:14] == 0x1
  OPC_Decode, 159, 13, 18,                   //  2006:      decode to X86RCRI_H using decoder 18
                                             //  2006:     }
  18, 8,                                     //  2010:     case 0x12: {
  OPC_CheckField, 15, 3, 1,                  //  2012:      check Inst[17:15] == 0x1
  OPC_Decode, 160, 13, 23,                   //  2016:      decode to X86RCRI_W using decoder 23
                                             //  2016:     }
  19, 10,                                    //  2020:     case 0x13: {
  OPC_CheckPredicate, 0,                     //  2022:      check predicate 0
  OPC_CheckField, 16, 2, 1,                  //  2024:      check Inst[17:16] == 0x1
  OPC_Decode, 158, 13, 24,                   //  2028:      decode to X86RCRI_D using decoder 24
                                             //  2028:     }
  20, 8,                                     //  2032:     case 0x14: {
  OPC_CheckField, 13, 5, 1,                  //  2034:      check Inst[17:13] == 0x1
  OPC_Decode, 165, 13, 22,                   //  2038:      decode to X86ROTLI_B using decoder 22
                                             //  2038:     }
  21, 8,                                     //  2042:     case 0x15: {
  OPC_CheckField, 14, 4, 1,                  //  2044:      check Inst[17:14] == 0x1
  OPC_Decode, 167, 13, 18,                   //  2048:      decode to X86ROTLI_H using decoder 18
                                             //  2048:     }
  22, 8,                                     //  2052:     case 0x16: {
  OPC_CheckField, 15, 3, 1,                  //  2054:      check Inst[17:15] == 0x1
  OPC_Decode, 168, 13, 23,                   //  2058:      decode to X86ROTLI_W using decoder 23
                                             //  2058:     }
  23, 10,                                    //  2062:     case 0x17: {
  OPC_CheckPredicate, 0,                     //  2064:      check predicate 0
  OPC_CheckField, 16, 2, 1,                  //  2066:      check Inst[17:16] == 0x1
  OPC_Decode, 166, 13, 24,                   //  2070:      decode to X86ROTLI_D using decoder 24
                                             //  2070:     }
  24, 8,                                     //  2074:     case 0x18: {
  OPC_CheckField, 13, 5, 1,                  //  2076:      check Inst[17:13] == 0x1
  OPC_Decode, 149, 13, 22,                   //  2080:      decode to X86RCLI_B using decoder 22
                                             //  2080:     }
  25, 8,                                     //  2084:     case 0x19: {
  OPC_CheckField, 14, 4, 1,                  //  2086:      check Inst[17:14] == 0x1
  OPC_Decode, 151, 13, 18,                   //  2090:      decode to X86RCLI_H using decoder 18
                                             //  2090:     }
  26, 8,                                     //  2094:     case 0x1a: {
  OPC_CheckField, 15, 3, 1,                  //  2096:      check Inst[17:15] == 0x1
  OPC_Decode, 152, 13, 23,                   //  2100:      decode to X86RCLI_W using decoder 23
                                             //  2100:     }
  27, 0,                                     //  2104:     case 0x1b: {
  OPC_CheckPredicate, 0,                     //  2106:      check predicate 0
  OPC_CheckField, 16, 2, 1,                  //  2108:      check Inst[17:16] == 0x1
  OPC_Decode, 150, 13, 24,                   //  2112:      decode to X86RCLI_D using decoder 24
                                             //  2112:     }
                                             //  2112:     } // switch Inst[4:0]
                                             //  2112:    }
  6, 4,                                      //  2116:    case 0x6: {
  OPC_Decode, 185, 13, 25,                   //  2118:     decode to X86SETTAG using decoder 25
                                             //  2118:    }
  7, 0,                                      //  2122:    case 0x7: {
  OPC_SwitchField, 5, 5,                     //  2124:     switch Inst[9:5] {
  0, 4,                                      //  2127:     case 0x0: {
  OPC_Decode, 133, 13, 26,                   //  2129:      decode to X86MFFLAG using decoder 26
                                             //  2129:     }
  1, 4,                                      //  2133:     case 0x1: {
  OPC_Decode, 135, 13, 26,                   //  2135:      decode to X86MTFLAG using decoder 26
                                             //  2135:     }
  2, 4,                                      //  2139:     case 0x2: {
  OPC_Decode, 133, 4, 26,                    //  2141:      decode to ARMMFFLAG using decoder 26
                                             //  2141:     }
  3, 0,                                      //  2145:     case 0x3: {
  OPC_Decode, 137, 4, 26,                    //  2147:      decode to ARMMTFLAG using decoder 26
                                             //  2147:     }
                                             //  2147:     } // switch Inst[9:5]
                                             //  2147:    }
                                             //  2147:    } // switch Inst[20:18]
                                             //  2147:   }
  1, 0,                                      //  2151:   case 0x1: {
  OPC_SwitchField, 15, 1,                    //  2153:    switch Inst[15] {
  0, 4,                                      //  2156:    case 0x0: {
  OPC_Decode, 172, 4, 27,                    //  2158:     decode to BSTRINS_W using decoder 27
                                             //  2158:    }
  1, 0,                                      //  2162:    case 0x1: {
  OPC_Decode, 174, 4, 28,                    //  2164:     decode to BSTRPICK_W using decoder 28
                                             //  2164:    }
                                             //  2164:    } // switch Inst[15]
                                             //  2164:   }
                                             //  2164:   } // switch Inst[21]
                                             //  2164:  }
  2, 6,                                      //  2168:  case 0x2: {
  OPC_CheckPredicate, 0,                     //  2170:   check predicate 0
  OPC_Decode, 171, 4, 29,                    //  2172:   decode to BSTRINS_D using decoder 29
                                             //  2172:  }
  3, 6,                                      //  2176:  case 0x3: {
  OPC_CheckPredicate, 0,                     //  2178:   check predicate 0
  OPC_Decode, 173, 4, 30,                    //  2180:   decode to BSTRPICK_D using decoder 30
                                             //  2180:  }
  4, 161, 4,                                 //  2184:  case 0x4: {
  OPC_SwitchField, 15, 7,                    //  2187:   switch Inst[21:15] {
  1, 4,                                      //  2190:   case 0x1: {
  OPC_Decode, 210, 4, 31,                    //  2192:    decode to FADD_S using decoder 31
                                             //  2192:   }
  2, 4,                                      //  2196:   case 0x2: {
  OPC_Decode, 209, 4, 32,                    //  2198:    decode to FADD_D using decoder 32
                                             //  2198:   }
  5, 4,                                      //  2202:   case 0x5: {
  OPC_Decode, 199, 5, 31,                    //  2204:    decode to FSUB_S using decoder 31
                                             //  2204:   }
  6, 4,                                      //  2208:   case 0x6: {
  OPC_Decode, 198, 5, 32,                    //  2210:    decode to FSUB_D using decoder 32
                                             //  2210:   }
  9, 4,                                      //  2214:   case 0x9: {
  OPC_Decode, 167, 5, 31,                    //  2216:    decode to FMUL_S using decoder 31
                                             //  2216:   }
  10, 4,                                     //  2220:   case 0xa: {
  OPC_Decode, 166, 5, 32,                    //  2222:    decode to FMUL_D using decoder 32
                                             //  2222:   }
  13, 4,                                     //  2226:   case 0xd: {
  OPC_Decode, 137, 5, 31,                    //  2228:    decode to FDIV_S using decoder 31
                                             //  2228:   }
  14, 4,                                     //  2232:   case 0xe: {
  OPC_Decode, 136, 5, 32,                    //  2234:    decode to FDIV_D using decoder 32
                                             //  2234:   }
  17, 4,                                     //  2238:   case 0x11: {
  OPC_Decode, 157, 5, 31,                    //  2240:    decode to FMAX_S using decoder 31
                                             //  2240:   }
  18, 4,                                     //  2244:   case 0x12: {
  OPC_Decode, 156, 5, 32,                    //  2246:    decode to FMAX_D using decoder 32
                                             //  2246:   }
  21, 4,                                     //  2250:   case 0x15: {
  OPC_Decode, 161, 5, 31,                    //  2252:    decode to FMIN_S using decoder 31
                                             //  2252:   }
  22, 4,                                     //  2256:   case 0x16: {
  OPC_Decode, 160, 5, 32,                    //  2258:    decode to FMIN_D using decoder 32
                                             //  2258:   }
  25, 4,                                     //  2262:   case 0x19: {
  OPC_Decode, 155, 5, 31,                    //  2264:    decode to FMAXA_S using decoder 31
                                             //  2264:   }
  26, 4,                                     //  2268:   case 0x1a: {
  OPC_Decode, 154, 5, 32,                    //  2270:    decode to FMAXA_D using decoder 32
                                             //  2270:   }
  29, 4,                                     //  2274:   case 0x1d: {
  OPC_Decode, 159, 5, 31,                    //  2276:    decode to FMINA_S using decoder 31
                                             //  2276:   }
  30, 4,                                     //  2280:   case 0x1e: {
  OPC_Decode, 158, 5, 32,                    //  2282:    decode to FMINA_D using decoder 32
                                             //  2282:   }
  33, 4,                                     //  2286:   case 0x21: {
  OPC_Decode, 185, 5, 31,                    //  2288:    decode to FSCALEB_S using decoder 31
                                             //  2288:   }
  34, 4,                                     //  2292:   case 0x22: {
  OPC_Decode, 184, 5, 32,                    //  2294:    decode to FSCALEB_D using decoder 32
                                             //  2294:   }
  37, 4,                                     //  2298:   case 0x25: {
  OPC_Decode, 130, 5, 31,                    //  2300:    decode to FCOPYSIGN_S using decoder 31
                                             //  2300:   }
  38, 4,                                     //  2304:   case 0x26: {
  OPC_Decode, 129, 5, 32,                    //  2306:    decode to FCOPYSIGN_D using decoder 32
                                             //  2306:   }
  40, 99,                                    //  2310:   case 0x28: {
  OPC_SwitchField, 10, 5,                    //  2312:    switch Inst[14:10] {
  1, 4,                                      //  2315:    case 0x1: {
  OPC_Decode, 208, 4, 33,                    //  2317:     decode to FABS_S using decoder 33
                                             //  2317:    }
  2, 4,                                      //  2321:    case 0x2: {
  OPC_Decode, 207, 4, 34,                    //  2323:     decode to FABS_D using decoder 34
                                             //  2323:    }
  5, 4,                                      //  2327:    case 0x5: {
  OPC_Decode, 169, 5, 33,                    //  2329:     decode to FNEG_S using decoder 33
                                             //  2329:    }
  6, 4,                                      //  2333:    case 0x6: {
  OPC_Decode, 168, 5, 34,                    //  2335:     decode to FNEG_D using decoder 34
                                             //  2335:    }
  9, 4,                                      //  2339:    case 0x9: {
  OPC_Decode, 151, 5, 33,                    //  2341:     decode to FLOGB_S using decoder 33
                                             //  2341:    }
  10, 4,                                     //  2345:    case 0xa: {
  OPC_Decode, 150, 5, 34,                    //  2347:     decode to FLOGB_D using decoder 34
                                             //  2347:    }
  13, 4,                                     //  2351:    case 0xd: {
  OPC_Decode, 212, 4, 33,                    //  2353:     decode to FCLASS_S using decoder 33
                                             //  2353:    }
  14, 4,                                     //  2357:    case 0xe: {
  OPC_Decode, 211, 4, 34,                    //  2359:     decode to FCLASS_D using decoder 34
                                             //  2359:    }
  17, 4,                                     //  2363:    case 0x11: {
  OPC_Decode, 189, 5, 33,                    //  2365:     decode to FSQRT_S using decoder 33
                                             //  2365:    }
  18, 4,                                     //  2369:    case 0x12: {
  OPC_Decode, 188, 5, 34,                    //  2371:     decode to FSQRT_D using decoder 34
                                             //  2371:    }
  21, 4,                                     //  2375:    case 0x15: {
  OPC_Decode, 177, 5, 33,                    //  2377:     decode to FRECIP_S using decoder 33
                                             //  2377:    }
  22, 4,                                     //  2381:    case 0x16: {
  OPC_Decode, 176, 5, 34,                    //  2383:     decode to FRECIP_D using decoder 34
                                             //  2383:    }
  25, 4,                                     //  2387:    case 0x19: {
  OPC_Decode, 183, 5, 33,                    //  2389:     decode to FRSQRT_S using decoder 33
                                             //  2389:    }
  26, 4,                                     //  2393:    case 0x1a: {
  OPC_Decode, 182, 5, 34,                    //  2395:     decode to FRSQRT_D using decoder 34
                                             //  2395:    }
  29, 4,                                     //  2399:    case 0x1d: {
  OPC_Decode, 175, 5, 33,                    //  2401:     decode to FRECIPE_S using decoder 33
                                             //  2401:    }
  30, 0,                                     //  2405:    case 0x1e: {
  OPC_Decode, 174, 5, 34,                    //  2407:     decode to FRECIPE_D using decoder 34
                                             //  2407:    }
                                             //  2407:    } // switch Inst[14:10]
                                             //  2407:   }
  41, 115,                                   //  2411:   case 0x29: {
  OPC_SwitchField, 10, 5,                    //  2413:    switch Inst[14:10] {
  1, 4,                                      //  2416:    case 0x1: {
  OPC_Decode, 181, 5, 33,                    //  2418:     decode to FRSQRTE_S using decoder 33
                                             //  2418:    }
  2, 4,                                      //  2422:    case 0x2: {
  OPC_Decode, 180, 5, 34,                    //  2424:     decode to FRSQRTE_D using decoder 34
                                             //  2424:    }
  5, 4,                                      //  2428:    case 0x5: {
  OPC_Decode, 163, 5, 33,                    //  2430:     decode to FMOV_S using decoder 33
                                             //  2430:    }
  6, 4,                                      //  2434:    case 0x6: {
  OPC_Decode, 162, 5, 34,                    //  2436:     decode to FMOV_D using decoder 34
                                             //  2436:    }
  9, 4,                                      //  2440:    case 0x9: {
  OPC_Decode, 166, 6, 35,                    //  2442:     decode to MOVGR2FR_W using decoder 35
                                             //  2442:    }
  10, 6,                                     //  2446:    case 0xa: {
  OPC_CheckPredicate, 0,                     //  2448:     check predicate 0
  OPC_Decode, 165, 6, 36,                    //  2450:     decode to MOVGR2FR_D using decoder 36
                                             //  2450:    }
  11, 4,                                     //  2454:    case 0xb: {
  OPC_Decode, 164, 6, 37,                    //  2456:     decode to MOVGR2FRH_W using decoder 37
                                             //  2456:    }
  13, 4,                                     //  2460:    case 0xd: {
  OPC_Decode, 159, 6, 38,                    //  2462:     decode to MOVFR2GR_S using decoder 38
                                             //  2462:    }
  14, 6,                                     //  2466:    case 0xe: {
  OPC_CheckPredicate, 0,                     //  2468:     check predicate 0
  OPC_Decode, 158, 6, 39,                    //  2470:     decode to MOVFR2GR_D using decoder 39
                                             //  2470:    }
  15, 4,                                     //  2474:    case 0xf: {
  OPC_Decode, 161, 6, 39,                    //  2476:     decode to MOVFRH2GR_S using decoder 39
                                             //  2476:    }
  16, 4,                                     //  2480:    case 0x10: {
  OPC_Decode, 163, 6, 40,                    //  2482:     decode to MOVGR2FCSR using decoder 40
                                             //  2482:    }
  18, 4,                                     //  2486:    case 0x12: {
  OPC_Decode, 156, 6, 41,                    //  2488:     decode to MOVFCSR2GR using decoder 41
                                             //  2488:    }
  20, 4,                                     //  2492:    case 0x14: {
  OPC_Decode, 157, 6, 42,                    //  2494:     decode to MOVFR2CF_xS using decoder 42
                                             //  2494:    }
  21, 4,                                     //  2498:    case 0x15: {
  OPC_Decode, 154, 6, 43,                    //  2500:     decode to MOVCF2FR_xS using decoder 43
                                             //  2500:    }
  22, 4,                                     //  2504:    case 0x16: {
  OPC_Decode, 162, 6, 44,                    //  2506:     decode to MOVGR2CF using decoder 44
                                             //  2506:    }
  23, 4,                                     //  2510:    case 0x17: {
  OPC_Decode, 155, 6, 45,                    //  2512:     decode to MOVCF2GR using decoder 45
                                             //  2512:    }
  24, 4,                                     //  2516:    case 0x18: {
  OPC_Decode, 133, 5, 33,                    //  2518:     decode to FCVT_LD_D using decoder 33
                                             //  2518:    }
  25, 0,                                     //  2522:    case 0x19: {
  OPC_Decode, 135, 5, 33,                    //  2524:     decode to FCVT_UD_D using decoder 33
                                             //  2524:    }
                                             //  2524:    } // switch Inst[14:10]
                                             //  2524:   }
  42, 4,                                     //  2528:   case 0x2a: {
  OPC_Decode, 131, 5, 31,                    //  2530:    decode to FCVT_D_LD using decoder 31
                                             //  2530:   }
  50, 15,                                    //  2534:   case 0x32: {
  OPC_SwitchField, 10, 5,                    //  2536:    switch Inst[14:10] {
  6, 4,                                      //  2539:    case 0x6: {
  OPC_Decode, 134, 5, 46,                    //  2541:     decode to FCVT_S_D using decoder 46
                                             //  2541:    }
  9, 0,                                      //  2545:    case 0x9: {
  OPC_Decode, 132, 5, 47,                    //  2547:     decode to FCVT_D_S using decoder 47
                                             //  2547:    }
                                             //  2547:    } // switch Inst[14:10]
                                             //  2547:   }
  52, 51,                                    //  2551:   case 0x34: {
  OPC_SwitchField, 10, 5,                    //  2553:    switch Inst[14:10] {
  1, 4,                                      //  2556:    case 0x1: {
  OPC_Decode, 203, 5, 33,                    //  2558:     decode to FTINTRM_W_S using decoder 33
                                             //  2558:    }
  2, 4,                                      //  2562:    case 0x2: {
  OPC_Decode, 202, 5, 46,                    //  2564:     decode to FTINTRM_W_D using decoder 46
                                             //  2564:    }
  9, 4,                                      //  2568:    case 0x9: {
  OPC_Decode, 201, 5, 47,                    //  2570:     decode to FTINTRM_L_S using decoder 47
                                             //  2570:    }
  10, 4,                                     //  2574:    case 0xa: {
  OPC_Decode, 200, 5, 34,                    //  2576:     decode to FTINTRM_L_D using decoder 34
                                             //  2576:    }
  17, 4,                                     //  2580:    case 0x11: {
  OPC_Decode, 211, 5, 33,                    //  2582:     decode to FTINTRP_W_S using decoder 33
                                             //  2582:    }
  18, 4,                                     //  2586:    case 0x12: {
  OPC_Decode, 210, 5, 46,                    //  2588:     decode to FTINTRP_W_D using decoder 46
                                             //  2588:    }
  25, 4,                                     //  2592:    case 0x19: {
  OPC_Decode, 209, 5, 47,                    //  2594:     decode to FTINTRP_L_S using decoder 47
                                             //  2594:    }
  26, 0,                                     //  2598:    case 0x1a: {
  OPC_Decode, 208, 5, 34,                    //  2600:     decode to FTINTRP_L_D using decoder 34
                                             //  2600:    }
                                             //  2600:    } // switch Inst[14:10]
                                             //  2600:   }
  53, 51,                                    //  2604:   case 0x35: {
  OPC_SwitchField, 10, 5,                    //  2606:    switch Inst[14:10] {
  1, 4,                                      //  2609:    case 0x1: {
  OPC_Decode, 215, 5, 33,                    //  2611:     decode to FTINTRZ_W_S using decoder 33
                                             //  2611:    }
  2, 4,                                      //  2615:    case 0x2: {
  OPC_Decode, 214, 5, 46,                    //  2617:     decode to FTINTRZ_W_D using decoder 46
                                             //  2617:    }
  9, 4,                                      //  2621:    case 0x9: {
  OPC_Decode, 213, 5, 47,                    //  2623:     decode to FTINTRZ_L_S using decoder 47
                                             //  2623:    }
  10, 4,                                     //  2627:    case 0xa: {
  OPC_Decode, 212, 5, 34,                    //  2629:     decode to FTINTRZ_L_D using decoder 34
                                             //  2629:    }
  17, 4,                                     //  2633:    case 0x11: {
  OPC_Decode, 207, 5, 33,                    //  2635:     decode to FTINTRNE_W_S using decoder 33
                                             //  2635:    }
  18, 4,                                     //  2639:    case 0x12: {
  OPC_Decode, 206, 5, 46,                    //  2641:     decode to FTINTRNE_W_D using decoder 46
                                             //  2641:    }
  25, 4,                                     //  2645:    case 0x19: {
  OPC_Decode, 205, 5, 47,                    //  2647:     decode to FTINTRNE_L_S using decoder 47
                                             //  2647:    }
  26, 0,                                     //  2651:    case 0x1a: {
  OPC_Decode, 204, 5, 34,                    //  2653:     decode to FTINTRNE_L_D using decoder 34
                                             //  2653:    }
                                             //  2653:    } // switch Inst[14:10]
                                             //  2653:   }
  54, 27,                                    //  2657:   case 0x36: {
  OPC_SwitchField, 10, 5,                    //  2659:    switch Inst[14:10] {
  1, 4,                                      //  2662:    case 0x1: {
  OPC_Decode, 219, 5, 33,                    //  2664:     decode to FTINT_W_S using decoder 33
                                             //  2664:    }
  2, 4,                                      //  2668:    case 0x2: {
  OPC_Decode, 218, 5, 46,                    //  2670:     decode to FTINT_W_D using decoder 46
                                             //  2670:    }
  9, 4,                                      //  2674:    case 0x9: {
  OPC_Decode, 217, 5, 47,                    //  2676:     decode to FTINT_L_S using decoder 47
                                             //  2676:    }
  10, 0,                                     //  2680:    case 0xa: {
  OPC_Decode, 216, 5, 34,                    //  2682:     decode to FTINT_L_D using decoder 34
                                             //  2682:    }
                                             //  2682:    } // switch Inst[14:10]
                                             //  2682:   }
  58, 27,                                    //  2686:   case 0x3a: {
  OPC_SwitchField, 10, 5,                    //  2688:    switch Inst[14:10] {
  4, 4,                                      //  2691:    case 0x4: {
  OPC_Decode, 141, 5, 33,                    //  2693:     decode to FFINT_S_W using decoder 33
                                             //  2693:    }
  6, 4,                                      //  2697:    case 0x6: {
  OPC_Decode, 140, 5, 46,                    //  2699:     decode to FFINT_S_L using decoder 46
                                             //  2699:    }
  8, 4,                                      //  2703:    case 0x8: {
  OPC_Decode, 139, 5, 47,                    //  2705:     decode to FFINT_D_W using decoder 47
                                             //  2705:    }
  10, 0,                                     //  2709:    case 0xa: {
  OPC_Decode, 138, 5, 34,                    //  2711:     decode to FFINT_D_L using decoder 34
                                             //  2711:    }
                                             //  2711:    } // switch Inst[14:10]
                                             //  2711:   }
  60, 0,                                     //  2715:   case 0x3c: {
  OPC_SwitchField, 10, 5,                    //  2717:    switch Inst[14:10] {
  17, 4,                                     //  2720:    case 0x11: {
  OPC_Decode, 179, 5, 33,                    //  2722:     decode to FRINT_S using decoder 33
                                             //  2722:    }
  18, 0,                                     //  2726:    case 0x12: {
  OPC_Decode, 178, 5, 34,                    //  2728:     decode to FRINT_D using decoder 34
                                             //  2728:    }
                                             //  2728:    } // switch Inst[14:10]
                                             //  2728:   }
                                             //  2728:   } // switch Inst[21:15]
                                             //  2728:  }
  8, 4,                                      //  2732:  case 0x8: {
  OPC_Decode, 233, 6, 48,                    //  2734:   decode to SLTI using decoder 48
                                             //  2734:  }
  9, 4,                                      //  2738:  case 0x9: {
  OPC_Decode, 235, 6, 48,                    //  2740:   decode to SLTUI using decoder 48
                                             //  2740:  }
  10, 4,                                     //  2744:  case 0xa: {
  OPC_Decode, 194, 3, 48,                    //  2746:   decode to ADDI_W using decoder 48
                                             //  2746:  }
  11, 6,                                     //  2750:  case 0xb: {
  OPC_CheckPredicate, 0,                     //  2752:   check predicate 0
  OPC_Decode, 193, 3, 48,                    //  2754:   decode to ADDI_D using decoder 48
                                             //  2754:  }
  12, 6,                                     //  2758:  case 0xc: {
  OPC_CheckPredicate, 0,                     //  2760:   check predicate 0
  OPC_Decode, 147, 6, 48,                    //  2762:   decode to LU52I_D using decoder 48
                                             //  2762:  }
  13, 4,                                     //  2766:  case 0xd: {
  OPC_Decode, 128, 4, 49,                    //  2768:   decode to ANDI using decoder 49
                                             //  2768:  }
  14, 4,                                     //  2772:  case 0xe: {
  OPC_Decode, 180, 6, 49,                    //  2774:   decode to ORI using decoder 49
                                             //  2774:  }
  15, 0,                                     //  2778:  case 0xf: {
  OPC_Decode, 222, 13, 49,                   //  2780:   decode to XORI using decoder 49
                                             //  2780:  }
                                             //  2780:  } // switch Inst[25:22]
                                             //  2780: }
  1, 233, 1,                                 //  2784: case 0x1: {
  OPC_SwitchField, 24, 2,                    //  2787:  switch Inst[25:24] {
  0, 21,                                     //  2790:  case 0x0: {
  OPC_Scope, 15,                             //  2792:   try {
  OPC_SwitchField, 5, 5,                     //  2794:    switch Inst[9:5] {
  0, 4,                                      //  2797:    case 0x0: {
  OPC_Decode, 191, 4, 50,                    //  2799:     decode to CSRRD using decoder 50
                                             //  2799:    }
  1, 0,                                      //  2803:    case 0x1: {
  OPC_Decode, 192, 4, 51,                    //  2805:     decode to CSRWR using decoder 51
                                             //  2805:    }
                                             //  2805:    } // switch Inst[9:5]
                                             //  2805:   } else try {
  OPC_Decode, 193, 4, 52,                    //  2809:    decode to CSRXCHG using decoder 52
                                             //  2809:   }
                                             //  2809:  }
  1, 21,                                     //  2813:  case 0x1: {
  OPC_Scope, 15,                             //  2815:   try {
  OPC_SwitchField, 5, 5,                     //  2817:    switch Inst[9:5] {
  0, 4,                                      //  2820:    case 0x0: {
  OPC_Decode, 220, 5, 50,                    //  2822:     decode to GCSRRD using decoder 50
                                             //  2822:    }
  1, 0,                                      //  2826:    case 0x1: {
  OPC_Decode, 221, 5, 51,                    //  2828:     decode to GCSRWR using decoder 51
                                             //  2828:    }
                                             //  2828:    } // switch Inst[9:5]
                                             //  2828:   } else try {
  OPC_Decode, 222, 5, 52,                    //  2832:    decode to GCSRXCHG using decoder 52
                                             //  2832:   }
                                             //  2832:  }
  2, 0,                                      //  2836:  case 0x2: {
  OPC_SwitchField, 22, 2,                    //  2838:   switch Inst[23:22] {
  0, 4,                                      //  2841:   case 0x0: {
  OPC_Decode, 177, 4, 53,                    //  2843:    decode to CACOP using decoder 53
                                             //  2843:   }
  1, 0,                                      //  2847:   case 0x1: {
  OPC_SwitchField, 18, 4,                    //  2849:    switch Inst[21:18] {
  0, 4,                                      //  2852:    case 0x0: {
  OPC_Decode, 239, 5, 54,                    //  2854:     decode to LDDIR using decoder 54
                                             //  2854:    }
  1, 8,                                      //  2858:    case 0x1: {
  OPC_CheckField, 0, 5, 0,                   //  2860:     check Inst[4:0] == 0x0
  OPC_Decode, 250, 5, 55,                    //  2864:     decode to LDPTE using decoder 55
                                             //  2864:    }
  2, 0,                                      //  2868:    case 0x2: {
  OPC_SwitchField, 15, 3,                    //  2870:     switch Inst[17:15] {
  0, 132, 1,                                 //  2873:     case 0x0: {
  OPC_SwitchField, 10, 5,                    //  2876:      switch Inst[14:10] {
  0, 4,                                      //  2879:      case 0x0: {
  OPC_Decode, 228, 5, 2,                     //  2881:       decode to IOCSRRD_B using decoder 2
                                             //  2881:      }
  1, 4,                                      //  2885:      case 0x1: {
  OPC_Decode, 230, 5, 2,                     //  2887:       decode to IOCSRRD_H using decoder 2
                                             //  2887:      }
  2, 4,                                      //  2891:      case 0x2: {
  OPC_Decode, 231, 5, 2,                     //  2893:       decode to IOCSRRD_W using decoder 2
                                             //  2893:      }
  3, 6,                                      //  2897:      case 0x3: {
  OPC_CheckPredicate, 0,                     //  2899:       check predicate 0
  OPC_Decode, 229, 5, 2,                     //  2901:       decode to IOCSRRD_D using decoder 2
                                             //  2901:      }
  4, 4,                                      //  2905:      case 0x4: {
  OPC_Decode, 232, 5, 2,                     //  2907:       decode to IOCSRWR_B using decoder 2
                                             //  2907:      }
  5, 4,                                      //  2911:      case 0x5: {
  OPC_Decode, 234, 5, 2,                     //  2913:       decode to IOCSRWR_H using decoder 2
                                             //  2913:      }
  6, 4,                                      //  2917:      case 0x6: {
  OPC_Decode, 235, 5, 2,                     //  2919:       decode to IOCSRWR_W using decoder 2
                                             //  2919:      }
  7, 6,                                      //  2923:      case 0x7: {
  OPC_CheckPredicate, 0,                     //  2925:       check predicate 0
  OPC_Decode, 233, 5, 2,                     //  2927:       decode to IOCSRWR_D using decoder 2
                                             //  2927:      }
  8, 8,                                      //  2931:      case 0x8: {
  OPC_CheckField, 0, 10, 0,                  //  2933:       check Inst[9:0] == 0x0
  OPC_Decode, 141, 7, 6,                     //  2937:       decode to TLBCLR using decoder 6
                                             //  2937:      }
  9, 15,                                     //  2941:      case 0x9: {
  OPC_SwitchField, 0, 10,                    //  2943:       switch Inst[9:0] {
  0, 4,                                      //  2946:       case 0x0: {
  OPC_Decode, 143, 7, 6,                     //  2948:        decode to TLBFLUSH using decoder 6
                                             //  2948:       }
  1, 0,                                      //  2952:       case 0x1: {
  OPC_Decode, 223, 5, 6,                     //  2954:        decode to GTLBFLUSH using decoder 6
                                             //  2954:       }
                                             //  2954:       } // switch Inst[9:0]
                                             //  2954:      }
  10, 8,                                     //  2958:      case 0xa: {
  OPC_CheckField, 0, 10, 0,                  //  2960:       check Inst[9:0] == 0x0
  OPC_Decode, 145, 7, 6,                     //  2964:       decode to TLBSRCH using decoder 6
                                             //  2964:      }
  11, 8,                                     //  2968:      case 0xb: {
  OPC_CheckField, 0, 10, 0,                  //  2970:       check Inst[9:0] == 0x0
  OPC_Decode, 144, 7, 6,                     //  2974:       decode to TLBRD using decoder 6
                                             //  2974:      }
  12, 8,                                     //  2978:      case 0xc: {
  OPC_CheckField, 0, 10, 0,                  //  2980:       check Inst[9:0] == 0x0
  OPC_Decode, 146, 7, 6,                     //  2984:       decode to TLBWR using decoder 6
                                             //  2984:      }
  13, 8,                                     //  2988:      case 0xd: {
  OPC_CheckField, 0, 10, 0,                  //  2990:       check Inst[9:0] == 0x0
  OPC_Decode, 142, 7, 6,                     //  2994:       decode to TLBFILL using decoder 6
                                             //  2994:      }
  14, 0,                                     //  2998:      case 0xe: {
  OPC_CheckField, 0, 10, 0,                  //  3000:       check Inst[9:0] == 0x0
  OPC_Decode, 204, 4, 6,                     //  3004:       decode to ERTN using decoder 6
                                             //  3004:      }
                                             //  3004:      } // switch Inst[14:10]
                                             //  3004:     }
  1, 4,                                      //  3008:     case 0x1: {
  OPC_Decode, 226, 5, 13,                    //  3010:      decode to IDLE using decoder 13
                                             //  3010:     }
  3, 0,                                      //  3014:     case 0x3: {
  OPC_Decode, 227, 5, 56,                    //  3016:      decode to INVTLB using decoder 56
                                             //  3016:     }
                                             //  3016:     } // switch Inst[17:15]
                                             //  3016:    }
                                             //  3016:    } // switch Inst[21:18]
                                             //  3016:   }
                                             //  3016:   } // switch Inst[23:22]
                                             //  3016:  }
                                             //  3016:  } // switch Inst[25:24]
                                             //  3016: }
  2, 147, 1,                                 //  3020: case 0x2: {
  OPC_SwitchField, 20, 6,                    //  3023:  switch Inst[25:20] {
  1, 4,                                      //  3026:  case 0x1: {
  OPC_Decode, 153, 5, 57,                    //  3028:   decode to FMADD_S using decoder 57
                                             //  3028:  }
  2, 4,                                      //  3032:  case 0x2: {
  OPC_Decode, 152, 5, 58,                    //  3034:   decode to FMADD_D using decoder 58
                                             //  3034:  }
  5, 4,                                      //  3038:  case 0x5: {
  OPC_Decode, 165, 5, 57,                    //  3040:   decode to FMSUB_S using decoder 57
                                             //  3040:  }
  6, 4,                                      //  3044:  case 0x6: {
  OPC_Decode, 164, 5, 58,                    //  3046:   decode to FMSUB_D using decoder 58
                                             //  3046:  }
  9, 4,                                      //  3050:  case 0x9: {
  OPC_Decode, 171, 5, 57,                    //  3052:   decode to FNMADD_S using decoder 57
                                             //  3052:  }
  10, 4,                                     //  3056:  case 0xa: {
  OPC_Decode, 170, 5, 58,                    //  3058:   decode to FNMADD_D using decoder 58
                                             //  3058:  }
  13, 4,                                     //  3062:  case 0xd: {
  OPC_Decode, 173, 5, 57,                    //  3064:   decode to FNMSUB_S using decoder 57
                                             //  3064:  }
  14, 4,                                     //  3068:  case 0xe: {
  OPC_Decode, 172, 5, 58,                    //  3070:   decode to FNMSUB_D using decoder 58
                                             //  3070:  }
  17, 4,                                     //  3074:  case 0x11: {
  OPC_Decode, 220, 8, 59,                    //  3076:   decode to VFMADD_S using decoder 59
                                             //  3076:  }
  18, 4,                                     //  3080:  case 0x12: {
  OPC_Decode, 219, 8, 59,                    //  3082:   decode to VFMADD_D using decoder 59
                                             //  3082:  }
  21, 4,                                     //  3086:  case 0x15: {
  OPC_Decode, 230, 8, 59,                    //  3088:   decode to VFMSUB_S using decoder 59
                                             //  3088:  }
  22, 4,                                     //  3092:  case 0x16: {
  OPC_Decode, 229, 8, 59,                    //  3094:   decode to VFMSUB_D using decoder 59
                                             //  3094:  }
  25, 4,                                     //  3098:  case 0x19: {
  OPC_Decode, 234, 8, 59,                    //  3100:   decode to VFNMADD_S using decoder 59
                                             //  3100:  }
  26, 4,                                     //  3104:  case 0x1a: {
  OPC_Decode, 233, 8, 59,                    //  3106:   decode to VFNMADD_D using decoder 59
                                             //  3106:  }
  29, 4,                                     //  3110:  case 0x1d: {
  OPC_Decode, 236, 8, 59,                    //  3112:   decode to VFNMSUB_S using decoder 59
                                             //  3112:  }
  30, 4,                                     //  3116:  case 0x1e: {
  OPC_Decode, 235, 8, 59,                    //  3118:   decode to VFNMSUB_D using decoder 59
                                             //  3118:  }
  33, 4,                                     //  3122:  case 0x21: {
  OPC_Decode, 155, 15, 60,                   //  3124:   decode to XVFMADD_S using decoder 60
                                             //  3124:  }
  34, 4,                                     //  3128:  case 0x22: {
  OPC_Decode, 154, 15, 60,                   //  3130:   decode to XVFMADD_D using decoder 60
                                             //  3130:  }
  37, 4,                                     //  3134:  case 0x25: {
  OPC_Decode, 165, 15, 60,                   //  3136:   decode to XVFMSUB_S using decoder 60
                                             //  3136:  }
  38, 4,                                     //  3140:  case 0x26: {
  OPC_Decode, 164, 15, 60,                   //  3142:   decode to XVFMSUB_D using decoder 60
                                             //  3142:  }
  41, 4,                                     //  3146:  case 0x29: {
  OPC_Decode, 169, 15, 60,                   //  3148:   decode to XVFNMADD_S using decoder 60
                                             //  3148:  }
  42, 4,                                     //  3152:  case 0x2a: {
  OPC_Decode, 168, 15, 60,                   //  3154:   decode to XVFNMADD_D using decoder 60
                                             //  3154:  }
  45, 4,                                     //  3158:  case 0x2d: {
  OPC_Decode, 171, 15, 60,                   //  3160:   decode to XVFNMSUB_S using decoder 60
                                             //  3160:  }
  46, 0,                                     //  3164:  case 0x2e: {
  OPC_Decode, 170, 15, 60,                   //  3166:   decode to XVFNMSUB_D using decoder 60
                                             //  3166:  }
                                             //  3166:  } // switch Inst[25:20]
                                             //  3166: }
  3, 145, 8,                                 //  3170: case 0x3: {
  OPC_SwitchField, 20, 6,                    //  3173:  switch Inst[25:20] {
  1, 223, 1,                                 //  3176:  case 0x1: {
  OPC_SwitchField, 15, 5,                    //  3179:   switch Inst[19:15] {
  0, 8,                                      //  3182:   case 0x0: {
  OPC_CheckField, 3, 2, 0,                   //  3184:    check Inst[4:3] == 0x0
  OPC_Decode, 214, 4, 61,                    //  3188:    decode to FCMP_CAF_S using decoder 61
                                             //  3188:   }
  1, 8,                                      //  3192:   case 0x1: {
  OPC_CheckField, 3, 2, 0,                   //  3194:    check Inst[4:3] == 0x0
  OPC_Decode, 236, 4, 61,                    //  3198:    decode to FCMP_SAF_S using decoder 61
                                             //  3198:   }
  2, 8,                                      //  3202:   case 0x2: {
  OPC_CheckField, 3, 2, 0,                   //  3204:    check Inst[4:3] == 0x0
  OPC_Decode, 220, 4, 61,                    //  3208:    decode to FCMP_CLT_S using decoder 61
                                             //  3208:   }
  3, 8,                                      //  3212:   case 0x3: {
  OPC_CheckField, 3, 2, 0,                   //  3214:    check Inst[4:3] == 0x0
  OPC_Decode, 242, 4, 61,                    //  3218:    decode to FCMP_SLT_S using decoder 61
                                             //  3218:   }
  4, 8,                                      //  3222:   case 0x4: {
  OPC_CheckField, 3, 2, 0,                   //  3224:    check Inst[4:3] == 0x0
  OPC_Decode, 216, 4, 61,                    //  3228:    decode to FCMP_CEQ_S using decoder 61
                                             //  3228:   }
  5, 8,                                      //  3232:   case 0x5: {
  OPC_CheckField, 3, 2, 0,                   //  3234:    check Inst[4:3] == 0x0
  OPC_Decode, 238, 4, 61,                    //  3238:    decode to FCMP_SEQ_S using decoder 61
                                             //  3238:   }
  6, 8,                                      //  3242:   case 0x6: {
  OPC_CheckField, 3, 2, 0,                   //  3244:    check Inst[4:3] == 0x0
  OPC_Decode, 218, 4, 61,                    //  3248:    decode to FCMP_CLE_S using decoder 61
                                             //  3248:   }
  7, 8,                                      //  3252:   case 0x7: {
  OPC_CheckField, 3, 2, 0,                   //  3254:    check Inst[4:3] == 0x0
  OPC_Decode, 240, 4, 61,                    //  3258:    decode to FCMP_SLE_S using decoder 61
                                             //  3258:   }
  8, 8,                                      //  3262:   case 0x8: {
  OPC_CheckField, 3, 2, 0,                   //  3264:    check Inst[4:3] == 0x0
  OPC_Decode, 234, 4, 61,                    //  3268:    decode to FCMP_CUN_S using decoder 61
                                             //  3268:   }
  9, 8,                                      //  3272:   case 0x9: {
  OPC_CheckField, 3, 2, 0,                   //  3274:    check Inst[4:3] == 0x0
  OPC_Decode, 128, 5, 61,                    //  3278:    decode to FCMP_SUN_S using decoder 61
                                             //  3278:   }
  10, 8,                                     //  3282:   case 0xa: {
  OPC_CheckField, 3, 2, 0,                   //  3284:    check Inst[4:3] == 0x0
  OPC_Decode, 230, 4, 61,                    //  3288:    decode to FCMP_CULT_S using decoder 61
                                             //  3288:   }
  11, 8,                                     //  3292:   case 0xb: {
  OPC_CheckField, 3, 2, 0,                   //  3294:    check Inst[4:3] == 0x0
  OPC_Decode, 252, 4, 61,                    //  3298:    decode to FCMP_SULT_S using decoder 61
                                             //  3298:   }
  12, 8,                                     //  3302:   case 0xc: {
  OPC_CheckField, 3, 2, 0,                   //  3304:    check Inst[4:3] == 0x0
  OPC_Decode, 226, 4, 61,                    //  3308:    decode to FCMP_CUEQ_S using decoder 61
                                             //  3308:   }
  13, 8,                                     //  3312:   case 0xd: {
  OPC_CheckField, 3, 2, 0,                   //  3314:    check Inst[4:3] == 0x0
  OPC_Decode, 248, 4, 61,                    //  3318:    decode to FCMP_SUEQ_S using decoder 61
                                             //  3318:   }
  14, 8,                                     //  3322:   case 0xe: {
  OPC_CheckField, 3, 2, 0,                   //  3324:    check Inst[4:3] == 0x0
  OPC_Decode, 228, 4, 61,                    //  3328:    decode to FCMP_CULE_S using decoder 61
                                             //  3328:   }
  15, 8,                                     //  3332:   case 0xf: {
  OPC_CheckField, 3, 2, 0,                   //  3334:    check Inst[4:3] == 0x0
  OPC_Decode, 250, 4, 61,                    //  3338:    decode to FCMP_SULE_S using decoder 61
                                             //  3338:   }
  16, 8,                                     //  3342:   case 0x10: {
  OPC_CheckField, 3, 2, 0,                   //  3344:    check Inst[4:3] == 0x0
  OPC_Decode, 222, 4, 61,                    //  3348:    decode to FCMP_CNE_S using decoder 61
                                             //  3348:   }
  17, 8,                                     //  3352:   case 0x11: {
  OPC_CheckField, 3, 2, 0,                   //  3354:    check Inst[4:3] == 0x0
  OPC_Decode, 244, 4, 61,                    //  3358:    decode to FCMP_SNE_S using decoder 61
                                             //  3358:   }
  20, 8,                                     //  3362:   case 0x14: {
  OPC_CheckField, 3, 2, 0,                   //  3364:    check Inst[4:3] == 0x0
  OPC_Decode, 224, 4, 61,                    //  3368:    decode to FCMP_COR_S using decoder 61
                                             //  3368:   }
  21, 8,                                     //  3372:   case 0x15: {
  OPC_CheckField, 3, 2, 0,                   //  3374:    check Inst[4:3] == 0x0
  OPC_Decode, 246, 4, 61,                    //  3378:    decode to FCMP_SOR_S using decoder 61
                                             //  3378:   }
  24, 8,                                     //  3382:   case 0x18: {
  OPC_CheckField, 3, 2, 0,                   //  3384:    check Inst[4:3] == 0x0
  OPC_Decode, 232, 4, 61,                    //  3388:    decode to FCMP_CUNE_S using decoder 61
                                             //  3388:   }
  25, 0,                                     //  3392:   case 0x19: {
  OPC_CheckField, 3, 2, 0,                   //  3394:    check Inst[4:3] == 0x0
  OPC_Decode, 254, 4, 61,                    //  3398:    decode to FCMP_SUNE_S using decoder 61
                                             //  3398:   }
                                             //  3398:   } // switch Inst[19:15]
                                             //  3398:  }
  2, 223, 1,                                 //  3402:  case 0x2: {
  OPC_SwitchField, 15, 5,                    //  3405:   switch Inst[19:15] {
  0, 8,                                      //  3408:   case 0x0: {
  OPC_CheckField, 3, 2, 0,                   //  3410:    check Inst[4:3] == 0x0
  OPC_Decode, 213, 4, 62,                    //  3414:    decode to FCMP_CAF_D using decoder 62
                                             //  3414:   }
  1, 8,                                      //  3418:   case 0x1: {
  OPC_CheckField, 3, 2, 0,                   //  3420:    check Inst[4:3] == 0x0
  OPC_Decode, 235, 4, 62,                    //  3424:    decode to FCMP_SAF_D using decoder 62
                                             //  3424:   }
  2, 8,                                      //  3428:   case 0x2: {
  OPC_CheckField, 3, 2, 0,                   //  3430:    check Inst[4:3] == 0x0
  OPC_Decode, 219, 4, 62,                    //  3434:    decode to FCMP_CLT_D using decoder 62
                                             //  3434:   }
  3, 8,                                      //  3438:   case 0x3: {
  OPC_CheckField, 3, 2, 0,                   //  3440:    check Inst[4:3] == 0x0
  OPC_Decode, 241, 4, 62,                    //  3444:    decode to FCMP_SLT_D using decoder 62
                                             //  3444:   }
  4, 8,                                      //  3448:   case 0x4: {
  OPC_CheckField, 3, 2, 0,                   //  3450:    check Inst[4:3] == 0x0
  OPC_Decode, 215, 4, 62,                    //  3454:    decode to FCMP_CEQ_D using decoder 62
                                             //  3454:   }
  5, 8,                                      //  3458:   case 0x5: {
  OPC_CheckField, 3, 2, 0,                   //  3460:    check Inst[4:3] == 0x0
  OPC_Decode, 237, 4, 62,                    //  3464:    decode to FCMP_SEQ_D using decoder 62
                                             //  3464:   }
  6, 8,                                      //  3468:   case 0x6: {
  OPC_CheckField, 3, 2, 0,                   //  3470:    check Inst[4:3] == 0x0
  OPC_Decode, 217, 4, 62,                    //  3474:    decode to FCMP_CLE_D using decoder 62
                                             //  3474:   }
  7, 8,                                      //  3478:   case 0x7: {
  OPC_CheckField, 3, 2, 0,                   //  3480:    check Inst[4:3] == 0x0
  OPC_Decode, 239, 4, 62,                    //  3484:    decode to FCMP_SLE_D using decoder 62
                                             //  3484:   }
  8, 8,                                      //  3488:   case 0x8: {
  OPC_CheckField, 3, 2, 0,                   //  3490:    check Inst[4:3] == 0x0
  OPC_Decode, 233, 4, 62,                    //  3494:    decode to FCMP_CUN_D using decoder 62
                                             //  3494:   }
  9, 8,                                      //  3498:   case 0x9: {
  OPC_CheckField, 3, 2, 0,                   //  3500:    check Inst[4:3] == 0x0
  OPC_Decode, 255, 4, 62,                    //  3504:    decode to FCMP_SUN_D using decoder 62
                                             //  3504:   }
  10, 8,                                     //  3508:   case 0xa: {
  OPC_CheckField, 3, 2, 0,                   //  3510:    check Inst[4:3] == 0x0
  OPC_Decode, 229, 4, 62,                    //  3514:    decode to FCMP_CULT_D using decoder 62
                                             //  3514:   }
  11, 8,                                     //  3518:   case 0xb: {
  OPC_CheckField, 3, 2, 0,                   //  3520:    check Inst[4:3] == 0x0
  OPC_Decode, 251, 4, 62,                    //  3524:    decode to FCMP_SULT_D using decoder 62
                                             //  3524:   }
  12, 8,                                     //  3528:   case 0xc: {
  OPC_CheckField, 3, 2, 0,                   //  3530:    check Inst[4:3] == 0x0
  OPC_Decode, 225, 4, 62,                    //  3534:    decode to FCMP_CUEQ_D using decoder 62
                                             //  3534:   }
  13, 8,                                     //  3538:   case 0xd: {
  OPC_CheckField, 3, 2, 0,                   //  3540:    check Inst[4:3] == 0x0
  OPC_Decode, 247, 4, 62,                    //  3544:    decode to FCMP_SUEQ_D using decoder 62
                                             //  3544:   }
  14, 8,                                     //  3548:   case 0xe: {
  OPC_CheckField, 3, 2, 0,                   //  3550:    check Inst[4:3] == 0x0
  OPC_Decode, 227, 4, 62,                    //  3554:    decode to FCMP_CULE_D using decoder 62
                                             //  3554:   }
  15, 8,                                     //  3558:   case 0xf: {
  OPC_CheckField, 3, 2, 0,                   //  3560:    check Inst[4:3] == 0x0
  OPC_Decode, 249, 4, 62,                    //  3564:    decode to FCMP_SULE_D using decoder 62
                                             //  3564:   }
  16, 8,                                     //  3568:   case 0x10: {
  OPC_CheckField, 3, 2, 0,                   //  3570:    check Inst[4:3] == 0x0
  OPC_Decode, 221, 4, 62,                    //  3574:    decode to FCMP_CNE_D using decoder 62
                                             //  3574:   }
  17, 8,                                     //  3578:   case 0x11: {
  OPC_CheckField, 3, 2, 0,                   //  3580:    check Inst[4:3] == 0x0
  OPC_Decode, 243, 4, 62,                    //  3584:    decode to FCMP_SNE_D using decoder 62
                                             //  3584:   }
  20, 8,                                     //  3588:   case 0x14: {
  OPC_CheckField, 3, 2, 0,                   //  3590:    check Inst[4:3] == 0x0
  OPC_Decode, 223, 4, 62,                    //  3594:    decode to FCMP_COR_D using decoder 62
                                             //  3594:   }
  21, 8,                                     //  3598:   case 0x15: {
  OPC_CheckField, 3, 2, 0,                   //  3600:    check Inst[4:3] == 0x0
  OPC_Decode, 245, 4, 62,                    //  3604:    decode to FCMP_SOR_D using decoder 62
                                             //  3604:   }
  24, 8,                                     //  3608:   case 0x18: {
  OPC_CheckField, 3, 2, 0,                   //  3610:    check Inst[4:3] == 0x0
  OPC_Decode, 231, 4, 62,                    //  3614:    decode to FCMP_CUNE_D using decoder 62
                                             //  3614:   }
  25, 0,                                     //  3618:   case 0x19: {
  OPC_CheckField, 3, 2, 0,                   //  3620:    check Inst[4:3] == 0x0
  OPC_Decode, 253, 4, 62,                    //  3624:    decode to FCMP_SUNE_D using decoder 62
                                             //  3624:   }
                                             //  3624:   } // switch Inst[19:15]
                                             //  3624:  }
  5, 135, 1,                                 //  3628:  case 0x5: {
  OPC_SwitchField, 15, 5,                    //  3631:   switch Inst[19:15] {
  0, 4,                                      //  3634:   case 0x0: {
  OPC_Decode, 159, 8, 63,                    //  3636:    decode to VFCMP_CAF_S using decoder 63
                                             //  3636:   }
  1, 4,                                      //  3640:   case 0x1: {
  OPC_Decode, 181, 8, 63,                    //  3642:    decode to VFCMP_SAF_S using decoder 63
                                             //  3642:   }
  2, 4,                                      //  3646:   case 0x2: {
  OPC_Decode, 165, 8, 63,                    //  3648:    decode to VFCMP_CLT_S using decoder 63
                                             //  3648:   }
  3, 4,                                      //  3652:   case 0x3: {
  OPC_Decode, 187, 8, 63,                    //  3654:    decode to VFCMP_SLT_S using decoder 63
                                             //  3654:   }
  4, 4,                                      //  3658:   case 0x4: {
  OPC_Decode, 161, 8, 63,                    //  3660:    decode to VFCMP_CEQ_S using decoder 63
                                             //  3660:   }
  5, 4,                                      //  3664:   case 0x5: {
  OPC_Decode, 183, 8, 63,                    //  3666:    decode to VFCMP_SEQ_S using decoder 63
                                             //  3666:   }
  6, 4,                                      //  3670:   case 0x6: {
  OPC_Decode, 163, 8, 63,                    //  3672:    decode to VFCMP_CLE_S using decoder 63
                                             //  3672:   }
  7, 4,                                      //  3676:   case 0x7: {
  OPC_Decode, 185, 8, 63,                    //  3678:    decode to VFCMP_SLE_S using decoder 63
                                             //  3678:   }
  8, 4,                                      //  3682:   case 0x8: {
  OPC_Decode, 179, 8, 63,                    //  3684:    decode to VFCMP_CUN_S using decoder 63
                                             //  3684:   }
  9, 4,                                      //  3688:   case 0x9: {
  OPC_Decode, 201, 8, 63,                    //  3690:    decode to VFCMP_SUN_S using decoder 63
                                             //  3690:   }
  10, 4,                                     //  3694:   case 0xa: {
  OPC_Decode, 175, 8, 63,                    //  3696:    decode to VFCMP_CULT_S using decoder 63
                                             //  3696:   }
  11, 4,                                     //  3700:   case 0xb: {
  OPC_Decode, 197, 8, 63,                    //  3702:    decode to VFCMP_SULT_S using decoder 63
                                             //  3702:   }
  12, 4,                                     //  3706:   case 0xc: {
  OPC_Decode, 171, 8, 63,                    //  3708:    decode to VFCMP_CUEQ_S using decoder 63
                                             //  3708:   }
  13, 4,                                     //  3712:   case 0xd: {
  OPC_Decode, 193, 8, 63,                    //  3714:    decode to VFCMP_SUEQ_S using decoder 63
                                             //  3714:   }
  14, 4,                                     //  3718:   case 0xe: {
  OPC_Decode, 173, 8, 63,                    //  3720:    decode to VFCMP_CULE_S using decoder 63
                                             //  3720:   }
  15, 4,                                     //  3724:   case 0xf: {
  OPC_Decode, 195, 8, 63,                    //  3726:    decode to VFCMP_SULE_S using decoder 63
                                             //  3726:   }
  16, 4,                                     //  3730:   case 0x10: {
  OPC_Decode, 167, 8, 63,                    //  3732:    decode to VFCMP_CNE_S using decoder 63
                                             //  3732:   }
  17, 4,                                     //  3736:   case 0x11: {
  OPC_Decode, 189, 8, 63,                    //  3738:    decode to VFCMP_SNE_S using decoder 63
                                             //  3738:   }
  20, 4,                                     //  3742:   case 0x14: {
  OPC_Decode, 169, 8, 63,                    //  3744:    decode to VFCMP_COR_S using decoder 63
                                             //  3744:   }
  21, 4,                                     //  3748:   case 0x15: {
  OPC_Decode, 191, 8, 63,                    //  3750:    decode to VFCMP_SOR_S using decoder 63
                                             //  3750:   }
  24, 4,                                     //  3754:   case 0x18: {
  OPC_Decode, 177, 8, 63,                    //  3756:    decode to VFCMP_CUNE_S using decoder 63
                                             //  3756:   }
  25, 0,                                     //  3760:   case 0x19: {
  OPC_Decode, 199, 8, 63,                    //  3762:    decode to VFCMP_SUNE_S using decoder 63
                                             //  3762:   }
                                             //  3762:   } // switch Inst[19:15]
                                             //  3762:  }
  6, 135, 1,                                 //  3766:  case 0x6: {
  OPC_SwitchField, 15, 5,                    //  3769:   switch Inst[19:15] {
  0, 4,                                      //  3772:   case 0x0: {
  OPC_Decode, 158, 8, 63,                    //  3774:    decode to VFCMP_CAF_D using decoder 63
                                             //  3774:   }
  1, 4,                                      //  3778:   case 0x1: {
  OPC_Decode, 180, 8, 63,                    //  3780:    decode to VFCMP_SAF_D using decoder 63
                                             //  3780:   }
  2, 4,                                      //  3784:   case 0x2: {
  OPC_Decode, 164, 8, 63,                    //  3786:    decode to VFCMP_CLT_D using decoder 63
                                             //  3786:   }
  3, 4,                                      //  3790:   case 0x3: {
  OPC_Decode, 186, 8, 63,                    //  3792:    decode to VFCMP_SLT_D using decoder 63
                                             //  3792:   }
  4, 4,                                      //  3796:   case 0x4: {
  OPC_Decode, 160, 8, 63,                    //  3798:    decode to VFCMP_CEQ_D using decoder 63
                                             //  3798:   }
  5, 4,                                      //  3802:   case 0x5: {
  OPC_Decode, 182, 8, 63,                    //  3804:    decode to VFCMP_SEQ_D using decoder 63
                                             //  3804:   }
  6, 4,                                      //  3808:   case 0x6: {
  OPC_Decode, 162, 8, 63,                    //  3810:    decode to VFCMP_CLE_D using decoder 63
                                             //  3810:   }
  7, 4,                                      //  3814:   case 0x7: {
  OPC_Decode, 184, 8, 63,                    //  3816:    decode to VFCMP_SLE_D using decoder 63
                                             //  3816:   }
  8, 4,                                      //  3820:   case 0x8: {
  OPC_Decode, 178, 8, 63,                    //  3822:    decode to VFCMP_CUN_D using decoder 63
                                             //  3822:   }
  9, 4,                                      //  3826:   case 0x9: {
  OPC_Decode, 200, 8, 63,                    //  3828:    decode to VFCMP_SUN_D using decoder 63
                                             //  3828:   }
  10, 4,                                     //  3832:   case 0xa: {
  OPC_Decode, 174, 8, 63,                    //  3834:    decode to VFCMP_CULT_D using decoder 63
                                             //  3834:   }
  11, 4,                                     //  3838:   case 0xb: {
  OPC_Decode, 196, 8, 63,                    //  3840:    decode to VFCMP_SULT_D using decoder 63
                                             //  3840:   }
  12, 4,                                     //  3844:   case 0xc: {
  OPC_Decode, 170, 8, 63,                    //  3846:    decode to VFCMP_CUEQ_D using decoder 63
                                             //  3846:   }
  13, 4,                                     //  3850:   case 0xd: {
  OPC_Decode, 192, 8, 63,                    //  3852:    decode to VFCMP_SUEQ_D using decoder 63
                                             //  3852:   }
  14, 4,                                     //  3856:   case 0xe: {
  OPC_Decode, 172, 8, 63,                    //  3858:    decode to VFCMP_CULE_D using decoder 63
                                             //  3858:   }
  15, 4,                                     //  3862:   case 0xf: {
  OPC_Decode, 194, 8, 63,                    //  3864:    decode to VFCMP_SULE_D using decoder 63
                                             //  3864:   }
  16, 4,                                     //  3868:   case 0x10: {
  OPC_Decode, 166, 8, 63,                    //  3870:    decode to VFCMP_CNE_D using decoder 63
                                             //  3870:   }
  17, 4,                                     //  3874:   case 0x11: {
  OPC_Decode, 188, 8, 63,                    //  3876:    decode to VFCMP_SNE_D using decoder 63
                                             //  3876:   }
  20, 4,                                     //  3880:   case 0x14: {
  OPC_Decode, 168, 8, 63,                    //  3882:    decode to VFCMP_COR_D using decoder 63
                                             //  3882:   }
  21, 4,                                     //  3886:   case 0x15: {
  OPC_Decode, 190, 8, 63,                    //  3888:    decode to VFCMP_SOR_D using decoder 63
                                             //  3888:   }
  24, 4,                                     //  3892:   case 0x18: {
  OPC_Decode, 176, 8, 63,                    //  3894:    decode to VFCMP_CUNE_D using decoder 63
                                             //  3894:   }
  25, 0,                                     //  3898:   case 0x19: {
  OPC_Decode, 198, 8, 63,                    //  3900:    decode to VFCMP_SUNE_D using decoder 63
                                             //  3900:   }
                                             //  3900:   } // switch Inst[19:15]
                                             //  3900:  }
  9, 135, 1,                                 //  3904:  case 0x9: {
  OPC_SwitchField, 15, 5,                    //  3907:   switch Inst[19:15] {
  0, 4,                                      //  3910:   case 0x0: {
  OPC_Decode, 222, 14, 64,                   //  3912:    decode to XVFCMP_CAF_S using decoder 64
                                             //  3912:   }
  1, 4,                                      //  3916:   case 0x1: {
  OPC_Decode, 244, 14, 64,                   //  3918:    decode to XVFCMP_SAF_S using decoder 64
                                             //  3918:   }
  2, 4,                                      //  3922:   case 0x2: {
  OPC_Decode, 228, 14, 64,                   //  3924:    decode to XVFCMP_CLT_S using decoder 64
                                             //  3924:   }
  3, 4,                                      //  3928:   case 0x3: {
  OPC_Decode, 250, 14, 64,                   //  3930:    decode to XVFCMP_SLT_S using decoder 64
                                             //  3930:   }
  4, 4,                                      //  3934:   case 0x4: {
  OPC_Decode, 224, 14, 64,                   //  3936:    decode to XVFCMP_CEQ_S using decoder 64
                                             //  3936:   }
  5, 4,                                      //  3940:   case 0x5: {
  OPC_Decode, 246, 14, 64,                   //  3942:    decode to XVFCMP_SEQ_S using decoder 64
                                             //  3942:   }
  6, 4,                                      //  3946:   case 0x6: {
  OPC_Decode, 226, 14, 64,                   //  3948:    decode to XVFCMP_CLE_S using decoder 64
                                             //  3948:   }
  7, 4,                                      //  3952:   case 0x7: {
  OPC_Decode, 248, 14, 64,                   //  3954:    decode to XVFCMP_SLE_S using decoder 64
                                             //  3954:   }
  8, 4,                                      //  3958:   case 0x8: {
  OPC_Decode, 242, 14, 64,                   //  3960:    decode to XVFCMP_CUN_S using decoder 64
                                             //  3960:   }
  9, 4,                                      //  3964:   case 0x9: {
  OPC_Decode, 136, 15, 64,                   //  3966:    decode to XVFCMP_SUN_S using decoder 64
                                             //  3966:   }
  10, 4,                                     //  3970:   case 0xa: {
  OPC_Decode, 238, 14, 64,                   //  3972:    decode to XVFCMP_CULT_S using decoder 64
                                             //  3972:   }
  11, 4,                                     //  3976:   case 0xb: {
  OPC_Decode, 132, 15, 64,                   //  3978:    decode to XVFCMP_SULT_S using decoder 64
                                             //  3978:   }
  12, 4,                                     //  3982:   case 0xc: {
  OPC_Decode, 234, 14, 64,                   //  3984:    decode to XVFCMP_CUEQ_S using decoder 64
                                             //  3984:   }
  13, 4,                                     //  3988:   case 0xd: {
  OPC_Decode, 128, 15, 64,                   //  3990:    decode to XVFCMP_SUEQ_S using decoder 64
                                             //  3990:   }
  14, 4,                                     //  3994:   case 0xe: {
  OPC_Decode, 236, 14, 64,                   //  3996:    decode to XVFCMP_CULE_S using decoder 64
                                             //  3996:   }
  15, 4,                                     //  4000:   case 0xf: {
  OPC_Decode, 130, 15, 64,                   //  4002:    decode to XVFCMP_SULE_S using decoder 64
                                             //  4002:   }
  16, 4,                                     //  4006:   case 0x10: {
  OPC_Decode, 230, 14, 64,                   //  4008:    decode to XVFCMP_CNE_S using decoder 64
                                             //  4008:   }
  17, 4,                                     //  4012:   case 0x11: {
  OPC_Decode, 252, 14, 64,                   //  4014:    decode to XVFCMP_SNE_S using decoder 64
                                             //  4014:   }
  20, 4,                                     //  4018:   case 0x14: {
  OPC_Decode, 232, 14, 64,                   //  4020:    decode to XVFCMP_COR_S using decoder 64
                                             //  4020:   }
  21, 4,                                     //  4024:   case 0x15: {
  OPC_Decode, 254, 14, 64,                   //  4026:    decode to XVFCMP_SOR_S using decoder 64
                                             //  4026:   }
  24, 4,                                     //  4030:   case 0x18: {
  OPC_Decode, 240, 14, 64,                   //  4032:    decode to XVFCMP_CUNE_S using decoder 64
                                             //  4032:   }
  25, 0,                                     //  4036:   case 0x19: {
  OPC_Decode, 134, 15, 64,                   //  4038:    decode to XVFCMP_SUNE_S using decoder 64
                                             //  4038:   }
                                             //  4038:   } // switch Inst[19:15]
                                             //  4038:  }
  10, 135, 1,                                //  4042:  case 0xa: {
  OPC_SwitchField, 15, 5,                    //  4045:   switch Inst[19:15] {
  0, 4,                                      //  4048:   case 0x0: {
  OPC_Decode, 221, 14, 64,                   //  4050:    decode to XVFCMP_CAF_D using decoder 64
                                             //  4050:   }
  1, 4,                                      //  4054:   case 0x1: {
  OPC_Decode, 243, 14, 64,                   //  4056:    decode to XVFCMP_SAF_D using decoder 64
                                             //  4056:   }
  2, 4,                                      //  4060:   case 0x2: {
  OPC_Decode, 227, 14, 64,                   //  4062:    decode to XVFCMP_CLT_D using decoder 64
                                             //  4062:   }
  3, 4,                                      //  4066:   case 0x3: {
  OPC_Decode, 249, 14, 64,                   //  4068:    decode to XVFCMP_SLT_D using decoder 64
                                             //  4068:   }
  4, 4,                                      //  4072:   case 0x4: {
  OPC_Decode, 223, 14, 64,                   //  4074:    decode to XVFCMP_CEQ_D using decoder 64
                                             //  4074:   }
  5, 4,                                      //  4078:   case 0x5: {
  OPC_Decode, 245, 14, 64,                   //  4080:    decode to XVFCMP_SEQ_D using decoder 64
                                             //  4080:   }
  6, 4,                                      //  4084:   case 0x6: {
  OPC_Decode, 225, 14, 64,                   //  4086:    decode to XVFCMP_CLE_D using decoder 64
                                             //  4086:   }
  7, 4,                                      //  4090:   case 0x7: {
  OPC_Decode, 247, 14, 64,                   //  4092:    decode to XVFCMP_SLE_D using decoder 64
                                             //  4092:   }
  8, 4,                                      //  4096:   case 0x8: {
  OPC_Decode, 241, 14, 64,                   //  4098:    decode to XVFCMP_CUN_D using decoder 64
                                             //  4098:   }
  9, 4,                                      //  4102:   case 0x9: {
  OPC_Decode, 135, 15, 64,                   //  4104:    decode to XVFCMP_SUN_D using decoder 64
                                             //  4104:   }
  10, 4,                                     //  4108:   case 0xa: {
  OPC_Decode, 237, 14, 64,                   //  4110:    decode to XVFCMP_CULT_D using decoder 64
                                             //  4110:   }
  11, 4,                                     //  4114:   case 0xb: {
  OPC_Decode, 131, 15, 64,                   //  4116:    decode to XVFCMP_SULT_D using decoder 64
                                             //  4116:   }
  12, 4,                                     //  4120:   case 0xc: {
  OPC_Decode, 233, 14, 64,                   //  4122:    decode to XVFCMP_CUEQ_D using decoder 64
                                             //  4122:   }
  13, 4,                                     //  4126:   case 0xd: {
  OPC_Decode, 255, 14, 64,                   //  4128:    decode to XVFCMP_SUEQ_D using decoder 64
                                             //  4128:   }
  14, 4,                                     //  4132:   case 0xe: {
  OPC_Decode, 235, 14, 64,                   //  4134:    decode to XVFCMP_CULE_D using decoder 64
                                             //  4134:   }
  15, 4,                                     //  4138:   case 0xf: {
  OPC_Decode, 129, 15, 64,                   //  4140:    decode to XVFCMP_SULE_D using decoder 64
                                             //  4140:   }
  16, 4,                                     //  4144:   case 0x10: {
  OPC_Decode, 229, 14, 64,                   //  4146:    decode to XVFCMP_CNE_D using decoder 64
                                             //  4146:   }
  17, 4,                                     //  4150:   case 0x11: {
  OPC_Decode, 251, 14, 64,                   //  4152:    decode to XVFCMP_SNE_D using decoder 64
                                             //  4152:   }
  20, 4,                                     //  4156:   case 0x14: {
  OPC_Decode, 231, 14, 64,                   //  4158:    decode to XVFCMP_COR_D using decoder 64
                                             //  4158:   }
  21, 4,                                     //  4162:   case 0x15: {
  OPC_Decode, 253, 14, 64,                   //  4164:    decode to XVFCMP_SOR_D using decoder 64
                                             //  4164:   }
  24, 4,                                     //  4168:   case 0x18: {
  OPC_Decode, 239, 14, 64,                   //  4170:    decode to XVFCMP_CUNE_D using decoder 64
                                             //  4170:   }
  25, 0,                                     //  4174:   case 0x19: {
  OPC_Decode, 133, 15, 64,                   //  4176:    decode to XVFCMP_SUNE_D using decoder 64
                                             //  4176:   }
                                             //  4176:   } // switch Inst[19:15]
                                             //  4176:  }
  16, 8,                                     //  4180:  case 0x10: {
  OPC_CheckField, 18, 2, 0,                  //  4182:   check Inst[19:18] == 0x0
  OPC_Decode, 187, 5, 65,                    //  4186:   decode to FSEL_xS using decoder 65
                                             //  4186:  }
  17, 4,                                     //  4190:  case 0x11: {
  OPC_Decode, 229, 7, 59,                    //  4192:   decode to VBITSEL_V using decoder 59
                                             //  4192:  }
  18, 4,                                     //  4196:  case 0x12: {
  OPC_Decode, 176, 14, 60,                   //  4198:   decode to XVBITSEL_V using decoder 60
                                             //  4198:  }
  21, 4,                                     //  4202:  case 0x15: {
  OPC_Decode, 153, 11, 59,                   //  4204:   decode to VSHUF_B using decoder 59
                                             //  4204:  }
  22, 0,                                     //  4208:  case 0x16: {
  OPC_Decode, 223, 17, 60,                   //  4210:   decode to XVSHUF_B using decoder 60
                                             //  4210:  }
                                             //  4210:  } // switch Inst[25:20]
                                             //  4210: }
  4, 6,                                      //  4214: case 0x4: {
  OPC_CheckPredicate, 0,                     //  4216:  check predicate 0
  OPC_Decode, 197, 3, 66,                    //  4218:  decode to ADDU16I_D using decoder 66
                                             //  4218: }
  5, 17,                                     //  4222: case 0x5: {
  OPC_SwitchField, 25, 1,                    //  4224:  switch Inst[25] {
  0, 4,                                      //  4227:  case 0x0: {
  OPC_Decode, 145, 6, 67,                    //  4229:   decode to LU12I_W using decoder 67
                                             //  4229:  }
  1, 0,                                      //  4233:  case 0x1: {
  OPC_CheckPredicate, 0,                     //  4235:   check predicate 0
  OPC_Decode, 146, 6, 68,                    //  4237:   decode to LU32I_D using decoder 68
                                             //  4237:  }
                                             //  4237:  } // switch Inst[25]
                                             //  4237: }
  6, 15,                                     //  4241: case 0x6: {
  OPC_SwitchField, 25, 1,                    //  4243:  switch Inst[25] {
  0, 4,                                      //  4246:  case 0x0: {
  OPC_Decode, 182, 6, 67,                    //  4248:   decode to PCADDI using decoder 67
                                             //  4248:  }
  1, 0,                                      //  4252:  case 0x1: {
  OPC_Decode, 185, 6, 67,                    //  4254:   decode to PCALAU12I using decoder 67
                                             //  4254:  }
                                             //  4254:  } // switch Inst[25]
                                             //  4254: }
  7, 17,                                     //  4258: case 0x7: {
  OPC_SwitchField, 25, 1,                    //  4260:  switch Inst[25] {
  0, 4,                                      //  4263:  case 0x0: {
  OPC_Decode, 183, 6, 67,                    //  4265:   decode to PCADDU12I using decoder 67
                                             //  4265:  }
  1, 0,                                      //  4269:  case 0x1: {
  OPC_CheckPredicate, 0,                     //  4271:   check predicate 0
  OPC_Decode, 184, 6, 67,                    //  4273:   decode to PCADDU18I using decoder 67
                                             //  4273:  }
                                             //  4273:  } // switch Inst[25]
                                             //  4273: }
  8, 31,                                     //  4277: case 0x8: {
  OPC_SwitchField, 24, 2,                    //  4279:  switch Inst[25:24] {
  0, 4,                                      //  4282:  case 0x0: {
  OPC_Decode, 144, 6, 69,                    //  4284:   decode to LL_W using decoder 69
                                             //  4284:  }
  1, 4,                                      //  4288:  case 0x1: {
  OPC_Decode, 221, 6, 70,                    //  4290:   decode to SC_W using decoder 70
                                             //  4290:  }
  2, 6,                                      //  4294:  case 0x2: {
  OPC_CheckPredicate, 0,                     //  4296:   check predicate 0
  OPC_Decode, 143, 6, 69,                    //  4298:   decode to LL_D using decoder 69
                                             //  4298:  }
  3, 0,                                      //  4302:  case 0x3: {
  OPC_CheckPredicate, 0,                     //  4304:   check predicate 0
  OPC_Decode, 219, 6, 70,                    //  4306:   decode to SC_D using decoder 70
                                             //  4306:  }
                                             //  4306:  } // switch Inst[25:24]
                                             //  4306: }
  9, 35,                                     //  4310: case 0x9: {
  OPC_SwitchField, 24, 2,                    //  4312:  switch Inst[25:24] {
  0, 6,                                      //  4315:  case 0x0: {
  OPC_CheckPredicate, 0,                     //  4317:   check predicate 0
  OPC_Decode, 252, 5, 69,                    //  4319:   decode to LDPTR_W using decoder 69
                                             //  4319:  }
  1, 6,                                      //  4323:  case 0x1: {
  OPC_CheckPredicate, 0,                     //  4325:   check predicate 0
  OPC_Decode, 255, 6, 69,                    //  4327:   decode to STPTR_W using decoder 69
                                             //  4327:  }
  2, 6,                                      //  4331:  case 0x2: {
  OPC_CheckPredicate, 0,                     //  4333:   check predicate 0
  OPC_Decode, 251, 5, 69,                    //  4335:   decode to LDPTR_D using decoder 69
                                             //  4335:  }
  3, 0,                                      //  4339:  case 0x3: {
  OPC_CheckPredicate, 0,                     //  4341:   check predicate 0
  OPC_Decode, 254, 6, 69,                    //  4343:   decode to STPTR_D using decoder 69
                                             //  4343:  }
                                             //  4343:  } // switch Inst[25:24]
                                             //  4343: }
  10, 105,                                   //  4347: case 0xa: {
  OPC_SwitchField, 22, 4,                    //  4349:  switch Inst[25:22] {
  0, 4,                                      //  4352:  case 0x0: {
  OPC_Decode, 134, 6, 48,                    //  4354:   decode to LD_B using decoder 48
                                             //  4354:  }
  1, 4,                                      //  4358:  case 0x1: {
  OPC_Decode, 137, 6, 48,                    //  4360:   decode to LD_H using decoder 48
                                             //  4360:  }
  2, 4,                                      //  4364:  case 0x2: {
  OPC_Decode, 139, 6, 48,                    //  4366:   decode to LD_W using decoder 48
                                             //  4366:  }
  3, 6,                                      //  4370:  case 0x3: {
  OPC_CheckPredicate, 0,                     //  4372:   check predicate 0
  OPC_Decode, 136, 6, 48,                    //  4374:   decode to LD_D using decoder 48
                                             //  4374:  }
  4, 4,                                      //  4378:  case 0x4: {
  OPC_Decode, 134, 7, 48,                    //  4380:   decode to ST_B using decoder 48
                                             //  4380:  }
  5, 4,                                      //  4384:  case 0x5: {
  OPC_Decode, 136, 7, 48,                    //  4386:   decode to ST_H using decoder 48
                                             //  4386:  }
  6, 4,                                      //  4390:  case 0x6: {
  OPC_Decode, 137, 7, 48,                    //  4392:   decode to ST_W using decoder 48
                                             //  4392:  }
  7, 6,                                      //  4396:  case 0x7: {
  OPC_CheckPredicate, 0,                     //  4398:   check predicate 0
  OPC_Decode, 135, 7, 48,                    //  4400:   decode to ST_D using decoder 48
                                             //  4400:  }
  8, 4,                                      //  4404:  case 0x8: {
  OPC_Decode, 135, 6, 48,                    //  4406:   decode to LD_BU using decoder 48
                                             //  4406:  }
  9, 4,                                      //  4410:  case 0x9: {
  OPC_Decode, 138, 6, 48,                    //  4412:   decode to LD_HU using decoder 48
                                             //  4412:  }
  10, 6,                                     //  4416:  case 0xa: {
  OPC_CheckPredicate, 0,                     //  4418:   check predicate 0
  OPC_Decode, 140, 6, 48,                    //  4420:   decode to LD_WU using decoder 48
                                             //  4420:  }
  11, 4,                                     //  4424:  case 0xb: {
  OPC_Decode, 186, 6, 53,                    //  4426:   decode to PRELD using decoder 53
                                             //  4426:  }
  12, 4,                                     //  4430:  case 0xc: {
  OPC_Decode, 149, 5, 71,                    //  4432:   decode to FLD_S using decoder 71
                                             //  4432:  }
  13, 4,                                     //  4436:  case 0xd: {
  OPC_Decode, 197, 5, 71,                    //  4438:   decode to FST_S using decoder 71
                                             //  4438:  }
  14, 4,                                     //  4442:  case 0xe: {
  OPC_Decode, 148, 5, 72,                    //  4444:   decode to FLD_D using decoder 72
                                             //  4444:  }
  15, 0,                                     //  4448:  case 0xf: {
  OPC_Decode, 196, 5, 72,                    //  4450:   decode to FST_D using decoder 72
                                             //  4450:  }
                                             //  4450:  } // switch Inst[25:22]
                                             //  4450: }
  11, 83,                                    //  4454: case 0xb: {
  OPC_SwitchField, 22, 4,                    //  4456:  switch Inst[25:22] {
  0, 4,                                      //  4459:  case 0x0: {
  OPC_Decode, 192, 9, 73,                    //  4461:   decode to VLD using decoder 73
                                             //  4461:  }
  1, 4,                                      //  4465:  case 0x1: {
  OPC_Decode, 203, 12, 73,                   //  4467:   decode to VST using decoder 73
                                             //  4467:  }
  2, 4,                                      //  4471:  case 0x2: {
  OPC_Decode, 128, 16, 74,                   //  4473:   decode to XVLD using decoder 74
                                             //  4473:  }
  3, 4,                                      //  4477:  case 0x3: {
  OPC_Decode, 145, 19, 74,                   //  4479:   decode to XVST using decoder 74
                                             //  4479:  }
  8, 4,                                      //  4483:  case 0x8: {
  OPC_Decode, 249, 5, 48,                    //  4485:   decode to LDL_W using decoder 48
                                             //  4485:  }
  9, 4,                                      //  4489:  case 0x9: {
  OPC_Decode, 254, 5, 48,                    //  4491:   decode to LDR_W using decoder 48
                                             //  4491:  }
  10, 6,                                     //  4495:  case 0xa: {
  OPC_CheckPredicate, 0,                     //  4497:   check predicate 0
  OPC_Decode, 248, 5, 48,                    //  4499:   decode to LDL_D using decoder 48
                                             //  4499:  }
  11, 6,                                     //  4503:  case 0xb: {
  OPC_CheckPredicate, 0,                     //  4505:   check predicate 0
  OPC_Decode, 253, 5, 48,                    //  4507:   decode to LDR_D using decoder 48
                                             //  4507:  }
  12, 4,                                     //  4511:  case 0xc: {
  OPC_Decode, 253, 6, 48,                    //  4513:   decode to STL_W using decoder 48
                                             //  4513:  }
  13, 4,                                     //  4517:  case 0xd: {
  OPC_Decode, 129, 7, 48,                    //  4519:   decode to STR_W using decoder 48
                                             //  4519:  }
  14, 6,                                     //  4523:  case 0xe: {
  OPC_CheckPredicate, 0,                     //  4525:   check predicate 0
  OPC_Decode, 252, 6, 48,                    //  4527:   decode to STL_D using decoder 48
                                             //  4527:  }
  15, 0,                                     //  4531:  case 0xf: {
  OPC_CheckPredicate, 0,                     //  4533:   check predicate 0
  OPC_Decode, 128, 7, 48,                    //  4535:   decode to STR_D using decoder 48
                                             //  4535:  }
                                             //  4535:  } // switch Inst[25:22]
                                             //  4535: }
  12, 164, 1,                                //  4539: case 0xc: {
  OPC_SwitchField, 23, 3,                    //  4542:  switch Inst[25:23] {
  0, 29,                                     //  4545:  case 0x0: {
  OPC_SwitchField, 21, 2,                    //  4547:   switch Inst[22:21] {
  0, 8,                                      //  4550:   case 0x0: {
  OPC_CheckField, 19, 2, 2,                  //  4552:    check Inst[20:19] == 0x2
  OPC_Decode, 195, 9, 75,                    //  4556:    decode to VLDREPL_D using decoder 75
                                             //  4556:   }
  1, 8,                                      //  4560:   case 0x1: {
  OPC_CheckField, 20, 1, 0,                  //  4562:    check Inst[20] == 0x0
  OPC_Decode, 197, 9, 76,                    //  4566:    decode to VLDREPL_W using decoder 76
                                             //  4566:   }
  2, 0,                                      //  4570:   case 0x2: {
  OPC_Decode, 196, 9, 77,                    //  4572:    decode to VLDREPL_H using decoder 77
                                             //  4572:   }
                                             //  4572:   } // switch Inst[22:21]
                                             //  4572:  }
  1, 8,                                      //  4576:  case 0x1: {
  OPC_CheckField, 22, 1, 0,                  //  4578:   check Inst[22] == 0x0
  OPC_Decode, 194, 9, 73,                    //  4582:   decode to VLDREPL_B using decoder 73
                                             //  4582:  }
  2, 29,                                     //  4586:  case 0x2: {
  OPC_SwitchField, 21, 2,                    //  4588:   switch Inst[22:21] {
  0, 8,                                      //  4591:   case 0x0: {
  OPC_CheckField, 19, 2, 2,                  //  4593:    check Inst[20:19] == 0x2
  OPC_Decode, 205, 12, 78,                   //  4597:    decode to VSTELM_D using decoder 78
                                             //  4597:   }
  1, 8,                                      //  4601:   case 0x1: {
  OPC_CheckField, 20, 1, 0,                  //  4603:    check Inst[20] == 0x0
  OPC_Decode, 207, 12, 79,                   //  4607:    decode to VSTELM_W using decoder 79
                                             //  4607:   }
  2, 0,                                      //  4611:   case 0x2: {
  OPC_Decode, 206, 12, 80,                   //  4613:    decode to VSTELM_H using decoder 80
                                             //  4613:   }
                                             //  4613:   } // switch Inst[22:21]
                                             //  4613:  }
  3, 8,                                      //  4617:  case 0x3: {
  OPC_CheckField, 22, 1, 0,                  //  4619:   check Inst[22] == 0x0
  OPC_Decode, 204, 12, 81,                   //  4623:   decode to VSTELM_B using decoder 81
                                             //  4623:  }
  4, 29,                                     //  4627:  case 0x4: {
  OPC_SwitchField, 21, 2,                    //  4629:   switch Inst[22:21] {
  0, 8,                                      //  4632:   case 0x0: {
  OPC_CheckField, 19, 2, 2,                  //  4634:    check Inst[20:19] == 0x2
  OPC_Decode, 131, 16, 82,                   //  4638:    decode to XVLDREPL_D using decoder 82
                                             //  4638:   }
  1, 8,                                      //  4642:   case 0x1: {
  OPC_CheckField, 20, 1, 0,                  //  4644:    check Inst[20] == 0x0
  OPC_Decode, 133, 16, 83,                   //  4648:    decode to XVLDREPL_W using decoder 83
                                             //  4648:   }
  2, 0,                                      //  4652:   case 0x2: {
  OPC_Decode, 132, 16, 84,                   //  4654:    decode to XVLDREPL_H using decoder 84
                                             //  4654:   }
                                             //  4654:   } // switch Inst[22:21]
                                             //  4654:  }
  5, 8,                                      //  4658:  case 0x5: {
  OPC_CheckField, 22, 1, 0,                  //  4660:   check Inst[22] == 0x0
  OPC_Decode, 130, 16, 74,                   //  4664:   decode to XVLDREPL_B using decoder 74
                                             //  4664:  }
  6, 30,                                     //  4668:  case 0x6: {
  OPC_SwitchField, 22, 1,                    //  4670:   switch Inst[22] {
  0, 19,                                     //  4673:   case 0x0: {
  OPC_SwitchField, 21, 1,                    //  4675:    switch Inst[21] {
  0, 8,                                      //  4678:    case 0x0: {
  OPC_CheckField, 20, 1, 1,                  //  4680:     check Inst[20] == 0x1
  OPC_Decode, 147, 19, 85,                   //  4684:     decode to XVSTELM_D using decoder 85
                                             //  4684:    }
  1, 0,                                      //  4688:    case 0x1: {
  OPC_Decode, 149, 19, 86,                   //  4690:     decode to XVSTELM_W using decoder 86
                                             //  4690:    }
                                             //  4690:    } // switch Inst[21]
                                             //  4690:   }
  1, 0,                                      //  4694:   case 0x1: {
  OPC_Decode, 148, 19, 87,                   //  4696:    decode to XVSTELM_H using decoder 87
                                             //  4696:   }
                                             //  4696:   } // switch Inst[22]
                                             //  4696:  }
  7, 0,                                      //  4700:  case 0x7: {
  OPC_Decode, 146, 19, 88,                   //  4702:   decode to XVSTELM_B using decoder 88
                                             //  4702:  }
                                             //  4702:  } // switch Inst[25:23]
                                             //  4702: }
  14, 250, 6,                                //  4706: case 0xe: {
  OPC_SwitchField, 15, 11,                   //  4709:  switch Inst[25:15] {
  0, 6,                                      //  4712:  case 0x0: {
  OPC_CheckPredicate, 0,                     //  4714:   check predicate 0
  OPC_Decode, 255, 5, 11,                    //  4716:   decode to LDX_B using decoder 11
                                             //  4716:  }
  8, 6,                                      //  4720:  case 0x8: {
  OPC_CheckPredicate, 0,                     //  4722:   check predicate 0
  OPC_Decode, 130, 6, 11,                    //  4724:   decode to LDX_H using decoder 11
                                             //  4724:  }
  16, 6,                                     //  4728:  case 0x10: {
  OPC_CheckPredicate, 0,                     //  4730:   check predicate 0
  OPC_Decode, 132, 6, 11,                    //  4732:   decode to LDX_W using decoder 11
                                             //  4732:  }
  24, 6,                                     //  4736:  case 0x18: {
  OPC_CheckPredicate, 0,                     //  4738:   check predicate 0
  OPC_Decode, 129, 6, 11,                    //  4740:   decode to LDX_D using decoder 11
                                             //  4740:  }
  32, 6,                                     //  4744:  case 0x20: {
  OPC_CheckPredicate, 0,                     //  4746:   check predicate 0
  OPC_Decode, 130, 7, 11,                    //  4748:   decode to STX_B using decoder 11
                                             //  4748:  }
  40, 6,                                     //  4752:  case 0x28: {
  OPC_CheckPredicate, 0,                     //  4754:   check predicate 0
  OPC_Decode, 132, 7, 11,                    //  4756:   decode to STX_H using decoder 11
                                             //  4756:  }
  48, 6,                                     //  4760:  case 0x30: {
  OPC_CheckPredicate, 0,                     //  4762:   check predicate 0
  OPC_Decode, 133, 7, 11,                    //  4764:   decode to STX_W using decoder 11
                                             //  4764:  }
  56, 6,                                     //  4768:  case 0x38: {
  OPC_CheckPredicate, 0,                     //  4770:   check predicate 0
  OPC_Decode, 131, 7, 11,                    //  4772:   decode to STX_D using decoder 11
                                             //  4772:  }
  64, 6,                                     //  4776:  case 0x40: {
  OPC_CheckPredicate, 0,                     //  4778:   check predicate 0
  OPC_Decode, 128, 6, 11,                    //  4780:   decode to LDX_BU using decoder 11
                                             //  4780:  }
  72, 6,                                     //  4784:  case 0x48: {
  OPC_CheckPredicate, 0,                     //  4786:   check predicate 0
  OPC_Decode, 131, 6, 11,                    //  4788:   decode to LDX_HU using decoder 11
                                             //  4788:  }
  80, 6,                                     //  4792:  case 0x50: {
  OPC_CheckPredicate, 0,                     //  4794:   check predicate 0
  OPC_Decode, 133, 6, 11,                    //  4796:   decode to LDX_WU using decoder 11
                                             //  4796:  }
  88, 6,                                     //  4800:  case 0x58: {
  OPC_CheckPredicate, 0,                     //  4802:   check predicate 0
  OPC_Decode, 187, 6, 89,                    //  4804:   decode to PRELDX using decoder 89
                                             //  4804:  }
  96, 4,                                     //  4808:  case 0x60: {
  OPC_Decode, 147, 5, 90,                    //  4810:   decode to FLDX_S using decoder 90
                                             //  4810:  }
  104, 4,                                    //  4814:  case 0x68: {
  OPC_Decode, 146, 5, 91,                    //  4816:   decode to FLDX_D using decoder 91
                                             //  4816:  }
  112, 4,                                    //  4820:  case 0x70: {
  OPC_Decode, 195, 5, 90,                    //  4822:   decode to FSTX_S using decoder 90
                                             //  4822:  }
  120, 4,                                    //  4826:  case 0x78: {
  OPC_Decode, 194, 5, 91,                    //  4828:   decode to FSTX_D using decoder 91
                                             //  4828:  }
  128, 1, 4,                                 //  4832:  case 0x80: {
  OPC_Decode, 198, 9, 92,                    //  4835:   decode to VLDX using decoder 92
                                             //  4835:  }
  136, 1, 4,                                 //  4839:  case 0x88: {
  OPC_Decode, 208, 12, 92,                   //  4842:   decode to VSTX using decoder 92
                                             //  4842:  }
  144, 1, 4,                                 //  4846:  case 0x90: {
  OPC_Decode, 134, 16, 93,                   //  4849:   decode to XVLDX using decoder 93
                                             //  4849:  }
  152, 1, 4,                                 //  4853:  case 0x98: {
  OPC_Decode, 150, 19, 93,                   //  4856:   decode to XVSTX using decoder 93
                                             //  4856:  }
  174, 1, 6,                                 //  4860:  case 0xae: {
  OPC_CheckPredicate, 0,                     //  4863:   check predicate 0
  OPC_Decode, 220, 6, 94,                    //  4865:   decode to SC_Q using decoder 94
                                             //  4865:  }
  175, 1, 35,                                //  4869:  case 0xaf: {
  OPC_SwitchField, 10, 5,                    //  4872:   switch Inst[14:10] {
  0, 6,                                      //  4875:   case 0x0: {
  OPC_CheckPredicate, 0,                     //  4877:    check predicate 0
  OPC_Decode, 142, 6, 2,                     //  4879:    decode to LLACQ_W using decoder 2
                                             //  4879:   }
  1, 6,                                      //  4883:   case 0x1: {
  OPC_CheckPredicate, 0,                     //  4885:    check predicate 0
  OPC_Decode, 218, 6, 95,                    //  4887:    decode to SCREL_W using decoder 95
                                             //  4887:   }
  2, 6,                                      //  4891:   case 0x2: {
  OPC_CheckPredicate, 0,                     //  4893:    check predicate 0
  OPC_Decode, 141, 6, 2,                     //  4895:    decode to LLACQ_D using decoder 2
                                             //  4895:   }
  3, 0,                                      //  4899:   case 0x3: {
  OPC_CheckPredicate, 0,                     //  4901:    check predicate 0
  OPC_Decode, 217, 6, 95,                    //  4903:    decode to SCREL_D using decoder 95
                                             //  4903:   }
                                             //  4903:   } // switch Inst[14:10]
                                             //  4903:  }
  176, 1, 6,                                 //  4907:  case 0xb0: {
  OPC_CheckPredicate, 0,                     //  4910:   check predicate 0
  OPC_Decode, 215, 3, 94,                    //  4912:   decode to AMCAS_B using decoder 94
                                             //  4912:  }
  177, 1, 6,                                 //  4916:  case 0xb1: {
  OPC_CheckPredicate, 0,                     //  4919:   check predicate 0
  OPC_Decode, 217, 3, 94,                    //  4921:   decode to AMCAS_H using decoder 94
                                             //  4921:  }
  178, 1, 6,                                 //  4925:  case 0xb2: {
  OPC_CheckPredicate, 0,                     //  4928:   check predicate 0
  OPC_Decode, 218, 3, 94,                    //  4930:   decode to AMCAS_W using decoder 94
                                             //  4930:  }
  179, 1, 6,                                 //  4934:  case 0xb3: {
  OPC_CheckPredicate, 0,                     //  4937:   check predicate 0
  OPC_Decode, 216, 3, 94,                    //  4939:   decode to AMCAS_D using decoder 94
                                             //  4939:  }
  180, 1, 6,                                 //  4943:  case 0xb4: {
  OPC_CheckPredicate, 0,                     //  4946:   check predicate 0
  OPC_Decode, 219, 3, 94,                    //  4948:   decode to AMCAS__DB_B using decoder 94
                                             //  4948:  }
  181, 1, 6,                                 //  4952:  case 0xb5: {
  OPC_CheckPredicate, 0,                     //  4955:   check predicate 0
  OPC_Decode, 221, 3, 94,                    //  4957:   decode to AMCAS__DB_H using decoder 94
                                             //  4957:  }
  182, 1, 6,                                 //  4961:  case 0xb6: {
  OPC_CheckPredicate, 0,                     //  4964:   check predicate 0
  OPC_Decode, 222, 3, 94,                    //  4966:   decode to AMCAS__DB_W using decoder 94
                                             //  4966:  }
  183, 1, 6,                                 //  4970:  case 0xb7: {
  OPC_CheckPredicate, 0,                     //  4973:   check predicate 0
  OPC_Decode, 220, 3, 94,                    //  4975:   decode to AMCAS__DB_D using decoder 94
                                             //  4975:  }
  184, 1, 6,                                 //  4979:  case 0xb8: {
  OPC_CheckPredicate, 0,                     //  4982:   check predicate 0
  OPC_Decode, 243, 3, 96,                    //  4984:   decode to AMSWAP_B using decoder 96
                                             //  4984:  }
  185, 1, 6,                                 //  4988:  case 0xb9: {
  OPC_CheckPredicate, 0,                     //  4991:   check predicate 0
  OPC_Decode, 245, 3, 96,                    //  4993:   decode to AMSWAP_H using decoder 96
                                             //  4993:  }
  186, 1, 6,                                 //  4997:  case 0xba: {
  OPC_CheckPredicate, 0,                     //  5000:   check predicate 0
  OPC_Decode, 203, 3, 96,                    //  5002:   decode to AMADD_B using decoder 96
                                             //  5002:  }
  187, 1, 6,                                 //  5006:  case 0xbb: {
  OPC_CheckPredicate, 0,                     //  5009:   check predicate 0
  OPC_Decode, 205, 3, 96,                    //  5011:   decode to AMADD_H using decoder 96
                                             //  5011:  }
  188, 1, 6,                                 //  5015:  case 0xbc: {
  OPC_CheckPredicate, 0,                     //  5018:   check predicate 0
  OPC_Decode, 247, 3, 96,                    //  5020:   decode to AMSWAP__DB_B using decoder 96
                                             //  5020:  }
  189, 1, 6,                                 //  5024:  case 0xbd: {
  OPC_CheckPredicate, 0,                     //  5027:   check predicate 0
  OPC_Decode, 249, 3, 96,                    //  5029:   decode to AMSWAP__DB_H using decoder 96
                                             //  5029:  }
  190, 1, 6,                                 //  5033:  case 0xbe: {
  OPC_CheckPredicate, 0,                     //  5036:   check predicate 0
  OPC_Decode, 207, 3, 96,                    //  5038:   decode to AMADD__DB_B using decoder 96
                                             //  5038:  }
  191, 1, 6,                                 //  5042:  case 0xbf: {
  OPC_CheckPredicate, 0,                     //  5045:   check predicate 0
  OPC_Decode, 209, 3, 96,                    //  5047:   decode to AMADD__DB_H using decoder 96
                                             //  5047:  }
  192, 1, 16,                                //  5051:  case 0xc0: {
  OPC_Scope, 8,                              //  5054:   try {
  OPC_CheckField, 10, 5, 1,                  //  5056:    check Inst[14:10] == 0x1
  OPC_Decode, 147, 7, 97,                    //  5060:    decode to UD using decoder 97
                                             //  5060:   } else try {
  OPC_CheckPredicate, 0,                     //  5064:    check predicate 0
  OPC_Decode, 246, 3, 97,                    //  5066:    decode to AMSWAP_W using decoder 97
                                             //  5066:   }
                                             //  5066:  }
  193, 1, 6,                                 //  5070:  case 0xc1: {
  OPC_CheckPredicate, 0,                     //  5073:   check predicate 0
  OPC_Decode, 244, 3, 96,                    //  5075:   decode to AMSWAP_D using decoder 96
                                             //  5075:  }
  194, 1, 6,                                 //  5079:  case 0xc2: {
  OPC_CheckPredicate, 0,                     //  5082:   check predicate 0
  OPC_Decode, 206, 3, 96,                    //  5084:   decode to AMADD_W using decoder 96
                                             //  5084:  }
  195, 1, 6,                                 //  5088:  case 0xc3: {
  OPC_CheckPredicate, 0,                     //  5091:   check predicate 0
  OPC_Decode, 204, 3, 96,                    //  5093:   decode to AMADD_D using decoder 96
                                             //  5093:  }
  196, 1, 6,                                 //  5097:  case 0xc4: {
  OPC_CheckPredicate, 0,                     //  5100:   check predicate 0
  OPC_Decode, 212, 3, 96,                    //  5102:   decode to AMAND_W using decoder 96
                                             //  5102:  }
  197, 1, 6,                                 //  5106:  case 0xc5: {
  OPC_CheckPredicate, 0,                     //  5109:   check predicate 0
  OPC_Decode, 211, 3, 96,                    //  5111:   decode to AMAND_D using decoder 96
                                             //  5111:  }
  198, 1, 6,                                 //  5115:  case 0xc6: {
  OPC_CheckPredicate, 0,                     //  5118:   check predicate 0
  OPC_Decode, 240, 3, 96,                    //  5120:   decode to AMOR_W using decoder 96
                                             //  5120:  }
  199, 1, 6,                                 //  5124:  case 0xc7: {
  OPC_CheckPredicate, 0,                     //  5127:   check predicate 0
  OPC_Decode, 239, 3, 96,                    //  5129:   decode to AMOR_D using decoder 96
                                             //  5129:  }
  200, 1, 6,                                 //  5133:  case 0xc8: {
  OPC_CheckPredicate, 0,                     //  5136:   check predicate 0
  OPC_Decode, 252, 3, 96,                    //  5138:   decode to AMXOR_W using decoder 96
                                             //  5138:  }
  201, 1, 6,                                 //  5142:  case 0xc9: {
  OPC_CheckPredicate, 0,                     //  5145:   check predicate 0
  OPC_Decode, 251, 3, 96,                    //  5147:   decode to AMXOR_D using decoder 96
                                             //  5147:  }
  202, 1, 6,                                 //  5151:  case 0xca: {
  OPC_CheckPredicate, 0,                     //  5154:   check predicate 0
  OPC_Decode, 225, 3, 96,                    //  5156:   decode to AMMAX_W using decoder 96
                                             //  5156:  }
  203, 1, 6,                                 //  5160:  case 0xcb: {
  OPC_CheckPredicate, 0,                     //  5163:   check predicate 0
  OPC_Decode, 223, 3, 96,                    //  5165:   decode to AMMAX_D using decoder 96
                                             //  5165:  }
  204, 1, 6,                                 //  5169:  case 0xcc: {
  OPC_CheckPredicate, 0,                     //  5172:   check predicate 0
  OPC_Decode, 233, 3, 96,                    //  5174:   decode to AMMIN_W using decoder 96
                                             //  5174:  }
  205, 1, 6,                                 //  5178:  case 0xcd: {
  OPC_CheckPredicate, 0,                     //  5181:   check predicate 0
  OPC_Decode, 231, 3, 96,                    //  5183:   decode to AMMIN_D using decoder 96
                                             //  5183:  }
  206, 1, 6,                                 //  5187:  case 0xce: {
  OPC_CheckPredicate, 0,                     //  5190:   check predicate 0
  OPC_Decode, 226, 3, 96,                    //  5192:   decode to AMMAX_WU using decoder 96
                                             //  5192:  }
  207, 1, 6,                                 //  5196:  case 0xcf: {
  OPC_CheckPredicate, 0,                     //  5199:   check predicate 0
  OPC_Decode, 224, 3, 96,                    //  5201:   decode to AMMAX_DU using decoder 96
                                             //  5201:  }
  208, 1, 6,                                 //  5205:  case 0xd0: {
  OPC_CheckPredicate, 0,                     //  5208:   check predicate 0
  OPC_Decode, 234, 3, 96,                    //  5210:   decode to AMMIN_WU using decoder 96
                                             //  5210:  }
  209, 1, 6,                                 //  5214:  case 0xd1: {
  OPC_CheckPredicate, 0,                     //  5217:   check predicate 0
  OPC_Decode, 232, 3, 96,                    //  5219:   decode to AMMIN_DU using decoder 96
                                             //  5219:  }
  210, 1, 6,                                 //  5223:  case 0xd2: {
  OPC_CheckPredicate, 0,                     //  5226:   check predicate 0
  OPC_Decode, 250, 3, 96,                    //  5228:   decode to AMSWAP__DB_W using decoder 96
                                             //  5228:  }
  211, 1, 6,                                 //  5232:  case 0xd3: {
  OPC_CheckPredicate, 0,                     //  5235:   check predicate 0
  OPC_Decode, 248, 3, 96,                    //  5237:   decode to AMSWAP__DB_D using decoder 96
                                             //  5237:  }
  212, 1, 6,                                 //  5241:  case 0xd4: {
  OPC_CheckPredicate, 0,                     //  5244:   check predicate 0
  OPC_Decode, 210, 3, 96,                    //  5246:   decode to AMADD__DB_W using decoder 96
                                             //  5246:  }
  213, 1, 6,                                 //  5250:  case 0xd5: {
  OPC_CheckPredicate, 0,                     //  5253:   check predicate 0
  OPC_Decode, 208, 3, 96,                    //  5255:   decode to AMADD__DB_D using decoder 96
                                             //  5255:  }
  214, 1, 6,                                 //  5259:  case 0xd6: {
  OPC_CheckPredicate, 0,                     //  5262:   check predicate 0
  OPC_Decode, 214, 3, 96,                    //  5264:   decode to AMAND__DB_W using decoder 96
                                             //  5264:  }
  215, 1, 6,                                 //  5268:  case 0xd7: {
  OPC_CheckPredicate, 0,                     //  5271:   check predicate 0
  OPC_Decode, 213, 3, 96,                    //  5273:   decode to AMAND__DB_D using decoder 96
                                             //  5273:  }
  216, 1, 6,                                 //  5277:  case 0xd8: {
  OPC_CheckPredicate, 0,                     //  5280:   check predicate 0
  OPC_Decode, 242, 3, 96,                    //  5282:   decode to AMOR__DB_W using decoder 96
                                             //  5282:  }
  217, 1, 6,                                 //  5286:  case 0xd9: {
  OPC_CheckPredicate, 0,                     //  5289:   check predicate 0
  OPC_Decode, 241, 3, 96,                    //  5291:   decode to AMOR__DB_D using decoder 96
                                             //  5291:  }
  218, 1, 6,                                 //  5295:  case 0xda: {
  OPC_CheckPredicate, 0,                     //  5298:   check predicate 0
  OPC_Decode, 254, 3, 96,                    //  5300:   decode to AMXOR__DB_W using decoder 96
                                             //  5300:  }
  219, 1, 6,                                 //  5304:  case 0xdb: {
  OPC_CheckPredicate, 0,                     //  5307:   check predicate 0
  OPC_Decode, 253, 3, 96,                    //  5309:   decode to AMXOR__DB_D using decoder 96
                                             //  5309:  }
  220, 1, 6,                                 //  5313:  case 0xdc: {
  OPC_CheckPredicate, 0,                     //  5316:   check predicate 0
  OPC_Decode, 229, 3, 96,                    //  5318:   decode to AMMAX__DB_W using decoder 96
                                             //  5318:  }
  221, 1, 6,                                 //  5322:  case 0xdd: {
  OPC_CheckPredicate, 0,                     //  5325:   check predicate 0
  OPC_Decode, 227, 3, 96,                    //  5327:   decode to AMMAX__DB_D using decoder 96
                                             //  5327:  }
  222, 1, 6,                                 //  5331:  case 0xde: {
  OPC_CheckPredicate, 0,                     //  5334:   check predicate 0
  OPC_Decode, 237, 3, 96,                    //  5336:   decode to AMMIN__DB_W using decoder 96
                                             //  5336:  }
  223, 1, 6,                                 //  5340:  case 0xdf: {
  OPC_CheckPredicate, 0,                     //  5343:   check predicate 0
  OPC_Decode, 235, 3, 96,                    //  5345:   decode to AMMIN__DB_D using decoder 96
                                             //  5345:  }
  224, 1, 6,                                 //  5349:  case 0xe0: {
  OPC_CheckPredicate, 0,                     //  5352:   check predicate 0
  OPC_Decode, 230, 3, 96,                    //  5354:   decode to AMMAX__DB_WU using decoder 96
                                             //  5354:  }
  225, 1, 6,                                 //  5358:  case 0xe1: {
  OPC_CheckPredicate, 0,                     //  5361:   check predicate 0
  OPC_Decode, 228, 3, 96,                    //  5363:   decode to AMMAX__DB_DU using decoder 96
                                             //  5363:  }
  226, 1, 6,                                 //  5367:  case 0xe2: {
  OPC_CheckPredicate, 0,                     //  5370:   check predicate 0
  OPC_Decode, 238, 3, 96,                    //  5372:   decode to AMMIN__DB_WU using decoder 96
                                             //  5372:  }
  227, 1, 6,                                 //  5376:  case 0xe3: {
  OPC_CheckPredicate, 0,                     //  5379:   check predicate 0
  OPC_Decode, 236, 3, 96,                    //  5381:   decode to AMMIN__DB_DU using decoder 96
                                             //  5381:  }
  228, 1, 4,                                 //  5385:  case 0xe4: {
  OPC_Decode, 198, 4, 13,                    //  5388:   decode to DBAR using decoder 13
                                             //  5388:  }
  229, 1, 4,                                 //  5392:  case 0xe5: {
  OPC_Decode, 225, 5, 13,                    //  5395:   decode to IBAR using decoder 13
                                             //  5395:  }
  232, 1, 4,                                 //  5399:  case 0xe8: {
  OPC_Decode, 143, 5, 90,                    //  5402:   decode to FLDGT_S using decoder 90
                                             //  5402:  }
  233, 1, 4,                                 //  5406:  case 0xe9: {
  OPC_Decode, 142, 5, 91,                    //  5409:   decode to FLDGT_D using decoder 91
                                             //  5409:  }
  234, 1, 4,                                 //  5413:  case 0xea: {
  OPC_Decode, 145, 5, 90,                    //  5416:   decode to FLDLE_S using decoder 90
                                             //  5416:  }
  235, 1, 4,                                 //  5420:  case 0xeb: {
  OPC_Decode, 144, 5, 91,                    //  5423:   decode to FLDLE_D using decoder 91
                                             //  5423:  }
  236, 1, 4,                                 //  5427:  case 0xec: {
  OPC_Decode, 191, 5, 90,                    //  5430:   decode to FSTGT_S using decoder 90
                                             //  5430:  }
  237, 1, 4,                                 //  5434:  case 0xed: {
  OPC_Decode, 190, 5, 91,                    //  5437:   decode to FSTGT_D using decoder 91
                                             //  5437:  }
  238, 1, 4,                                 //  5441:  case 0xee: {
  OPC_Decode, 193, 5, 90,                    //  5444:   decode to FSTLE_S using decoder 90
                                             //  5444:  }
  239, 1, 4,                                 //  5448:  case 0xef: {
  OPC_Decode, 192, 5, 91,                    //  5451:   decode to FSTLE_D using decoder 91
                                             //  5451:  }
  240, 1, 6,                                 //  5455:  case 0xf0: {
  OPC_CheckPredicate, 0,                     //  5458:   check predicate 0
  OPC_Decode, 240, 5, 11,                    //  5460:   decode to LDGT_B using decoder 11
                                             //  5460:  }
  241, 1, 6,                                 //  5464:  case 0xf1: {
  OPC_CheckPredicate, 0,                     //  5467:   check predicate 0
  OPC_Decode, 242, 5, 11,                    //  5469:   decode to LDGT_H using decoder 11
                                             //  5469:  }
  242, 1, 6,                                 //  5473:  case 0xf2: {
  OPC_CheckPredicate, 0,                     //  5476:   check predicate 0
  OPC_Decode, 243, 5, 11,                    //  5478:   decode to LDGT_W using decoder 11
                                             //  5478:  }
  243, 1, 6,                                 //  5482:  case 0xf3: {
  OPC_CheckPredicate, 0,                     //  5485:   check predicate 0
  OPC_Decode, 241, 5, 11,                    //  5487:   decode to LDGT_D using decoder 11
                                             //  5487:  }
  244, 1, 6,                                 //  5491:  case 0xf4: {
  OPC_CheckPredicate, 0,                     //  5494:   check predicate 0
  OPC_Decode, 244, 5, 11,                    //  5496:   decode to LDLE_B using decoder 11
                                             //  5496:  }
  245, 1, 6,                                 //  5500:  case 0xf5: {
  OPC_CheckPredicate, 0,                     //  5503:   check predicate 0
  OPC_Decode, 246, 5, 11,                    //  5505:   decode to LDLE_H using decoder 11
                                             //  5505:  }
  246, 1, 6,                                 //  5509:  case 0xf6: {
  OPC_CheckPredicate, 0,                     //  5512:   check predicate 0
  OPC_Decode, 247, 5, 11,                    //  5514:   decode to LDLE_W using decoder 11
                                             //  5514:  }
  247, 1, 6,                                 //  5518:  case 0xf7: {
  OPC_CheckPredicate, 0,                     //  5521:   check predicate 0
  OPC_Decode, 245, 5, 11,                    //  5523:   decode to LDLE_D using decoder 11
                                             //  5523:  }
  248, 1, 6,                                 //  5527:  case 0xf8: {
  OPC_CheckPredicate, 0,                     //  5530:   check predicate 0
  OPC_Decode, 244, 6, 11,                    //  5532:   decode to STGT_B using decoder 11
                                             //  5532:  }
  249, 1, 6,                                 //  5536:  case 0xf9: {
  OPC_CheckPredicate, 0,                     //  5539:   check predicate 0
  OPC_Decode, 246, 6, 11,                    //  5541:   decode to STGT_H using decoder 11
                                             //  5541:  }
  250, 1, 6,                                 //  5545:  case 0xfa: {
  OPC_CheckPredicate, 0,                     //  5548:   check predicate 0
  OPC_Decode, 247, 6, 11,                    //  5550:   decode to STGT_W using decoder 11
                                             //  5550:  }
  251, 1, 6,                                 //  5554:  case 0xfb: {
  OPC_CheckPredicate, 0,                     //  5557:   check predicate 0
  OPC_Decode, 245, 6, 11,                    //  5559:   decode to STGT_D using decoder 11
                                             //  5559:  }
  252, 1, 6,                                 //  5563:  case 0xfc: {
  OPC_CheckPredicate, 0,                     //  5566:   check predicate 0
  OPC_Decode, 248, 6, 11,                    //  5568:   decode to STLE_B using decoder 11
                                             //  5568:  }
  253, 1, 6,                                 //  5572:  case 0xfd: {
  OPC_CheckPredicate, 0,                     //  5575:   check predicate 0
  OPC_Decode, 250, 6, 11,                    //  5577:   decode to STLE_H using decoder 11
                                             //  5577:  }
  254, 1, 6,                                 //  5581:  case 0xfe: {
  OPC_CheckPredicate, 0,                     //  5584:   check predicate 0
  OPC_Decode, 251, 6, 11,                    //  5586:   decode to STLE_W using decoder 11
                                             //  5586:  }
  255, 1, 0,                                 //  5590:  case 0xff: {
  OPC_CheckPredicate, 0,                     //  5593:   check predicate 0
  OPC_Decode, 249, 6, 11,                    //  5595:   decode to STLE_D using decoder 11
                                             //  5595:  }
                                             //  5595:  } // switch Inst[25:15]
                                             //  5595: }
  16, 4,                                     //  5599: case 0x10: {
  OPC_Decode, 158, 4, 98,                    //  5601:  decode to BEQZ using decoder 98
                                             //  5601: }
  17, 4,                                     //  5605: case 0x11: {
  OPC_Decode, 169, 4, 98,                    //  5607:  decode to BNEZ using decoder 98
                                             //  5607: }
  18, 35,                                    //  5611: case 0x12: {
  OPC_SwitchField, 8, 2,                     //  5613:  switch Inst[9:8] {
  0, 4,                                      //  5616:  case 0x0: {
  OPC_Decode, 155, 4, 99,                    //  5618:   decode to BCEQZ using decoder 99
                                             //  5618:  }
  1, 4,                                      //  5622:  case 0x1: {
  OPC_Decode, 156, 4, 99,                    //  5624:   decode to BCNEZ using decoder 99
                                             //  5624:  }
  2, 8,                                      //  5628:  case 0x2: {
  OPC_CheckField, 5, 3, 0,                   //  5630:   check Inst[7:5] == 0x0
  OPC_Decode, 237, 5, 100,                   //  5634:   decode to JISCR0 using decoder 100
                                             //  5634:  }
  3, 0,                                      //  5638:  case 0x3: {
  OPC_CheckField, 5, 3, 0,                   //  5640:   check Inst[7:5] == 0x0
  OPC_Decode, 238, 5, 100,                   //  5644:   decode to JISCR1 using decoder 100
                                             //  5644:  }
                                             //  5644:  } // switch Inst[9:8]
                                             //  5644: }
  19, 4,                                     //  5648: case 0x13: {
  OPC_Decode, 236, 5, 101,                   //  5650:  decode to JIRL using decoder 101
                                             //  5650: }
  20, 4,                                     //  5654: case 0x14: {
  OPC_Decode, 154, 4, 102,                   //  5656:  decode to B using decoder 102
                                             //  5656: }
  21, 4,                                     //  5660: case 0x15: {
  OPC_Decode, 165, 4, 102,                   //  5662:  decode to BL using decoder 102
                                             //  5662: }
  22, 4,                                     //  5666: case 0x16: {
  OPC_Decode, 157, 4, 103,                   //  5668:  decode to BEQ using decoder 103
                                             //  5668: }
  23, 4,                                     //  5672: case 0x17: {
  OPC_Decode, 168, 4, 103,                   //  5674:  decode to BNE using decoder 103
                                             //  5674: }
  24, 4,                                     //  5678: case 0x18: {
  OPC_Decode, 166, 4, 103,                   //  5680:  decode to BLT using decoder 103
                                             //  5680: }
  25, 4,                                     //  5684: case 0x19: {
  OPC_Decode, 159, 4, 103,                   //  5686:  decode to BGE using decoder 103
                                             //  5686: }
  26, 4,                                     //  5690: case 0x1a: {
  OPC_Decode, 167, 4, 103,                   //  5692:  decode to BLTU using decoder 103
                                             //  5692: }
  27, 4,                                     //  5696: case 0x1b: {
  OPC_Decode, 160, 4, 103,                   //  5698:  decode to BGEU using decoder 103
                                             //  5698: }
  28, 201, 38,                               //  5702: case 0x1c: {
  OPC_SwitchField, 18, 8,                    //  5705:  switch Inst[25:18] {
  0, 51,                                     //  5708:  case 0x0: {
  OPC_SwitchField, 15, 3,                    //  5710:   switch Inst[17:15] {
  0, 4,                                      //  5713:   case 0x0: {
  OPC_Decode, 135, 11, 63,                   //  5715:    decode to VSEQ_B using decoder 63
                                             //  5715:   }
  1, 4,                                      //  5719:   case 0x1: {
  OPC_Decode, 137, 11, 63,                   //  5721:    decode to VSEQ_H using decoder 63
                                             //  5721:   }
  2, 4,                                      //  5725:   case 0x2: {
  OPC_Decode, 138, 11, 63,                   //  5727:    decode to VSEQ_W using decoder 63
                                             //  5727:   }
  3, 4,                                      //  5731:   case 0x3: {
  OPC_Decode, 136, 11, 63,                   //  5733:    decode to VSEQ_D using decoder 63
                                             //  5733:   }
  4, 4,                                      //  5737:   case 0x4: {
  OPC_Decode, 169, 11, 63,                   //  5739:    decode to VSLE_B using decoder 63
                                             //  5739:   }
  5, 4,                                      //  5743:   case 0x5: {
  OPC_Decode, 173, 11, 63,                   //  5745:    decode to VSLE_H using decoder 63
                                             //  5745:   }
  6, 4,                                      //  5749:   case 0x6: {
  OPC_Decode, 175, 11, 63,                   //  5751:    decode to VSLE_W using decoder 63
                                             //  5751:   }
  7, 0,                                      //  5755:   case 0x7: {
  OPC_Decode, 171, 11, 63,                   //  5757:    decode to VSLE_D using decoder 63
                                             //  5757:   }
                                             //  5757:   } // switch Inst[17:15]
                                             //  5757:  }
  1, 51,                                     //  5761:  case 0x1: {
  OPC_SwitchField, 15, 3,                    //  5763:   switch Inst[17:15] {
  0, 4,                                      //  5766:   case 0x0: {
  OPC_Decode, 170, 11, 63,                   //  5768:    decode to VSLE_BU using decoder 63
                                             //  5768:   }
  1, 4,                                      //  5772:   case 0x1: {
  OPC_Decode, 174, 11, 63,                   //  5774:    decode to VSLE_HU using decoder 63
                                             //  5774:   }
  2, 4,                                      //  5778:   case 0x2: {
  OPC_Decode, 176, 11, 63,                   //  5780:    decode to VSLE_WU using decoder 63
                                             //  5780:   }
  3, 4,                                      //  5784:   case 0x3: {
  OPC_Decode, 172, 11, 63,                   //  5786:    decode to VSLE_DU using decoder 63
                                             //  5786:   }
  4, 4,                                      //  5790:   case 0x4: {
  OPC_Decode, 199, 11, 63,                   //  5792:    decode to VSLT_B using decoder 63
                                             //  5792:   }
  5, 4,                                      //  5796:   case 0x5: {
  OPC_Decode, 203, 11, 63,                   //  5798:    decode to VSLT_H using decoder 63
                                             //  5798:   }
  6, 4,                                      //  5802:   case 0x6: {
  OPC_Decode, 205, 11, 63,                   //  5804:    decode to VSLT_W using decoder 63
                                             //  5804:   }
  7, 0,                                      //  5808:   case 0x7: {
  OPC_Decode, 201, 11, 63,                   //  5810:    decode to VSLT_D using decoder 63
                                             //  5810:   }
                                             //  5810:   } // switch Inst[17:15]
                                             //  5810:  }
  2, 51,                                     //  5814:  case 0x2: {
  OPC_SwitchField, 15, 3,                    //  5816:   switch Inst[17:15] {
  0, 4,                                      //  5819:   case 0x0: {
  OPC_Decode, 200, 11, 63,                   //  5821:    decode to VSLT_BU using decoder 63
                                             //  5821:   }
  1, 4,                                      //  5825:   case 0x1: {
  OPC_Decode, 204, 11, 63,                   //  5827:    decode to VSLT_HU using decoder 63
                                             //  5827:   }
  2, 4,                                      //  5831:   case 0x2: {
  OPC_Decode, 206, 11, 63,                   //  5833:    decode to VSLT_WU using decoder 63
                                             //  5833:   }
  3, 4,                                      //  5837:   case 0x3: {
  OPC_Decode, 202, 11, 63,                   //  5839:    decode to VSLT_DU using decoder 63
                                             //  5839:   }
  4, 4,                                      //  5843:   case 0x4: {
  OPC_Decode, 188, 7, 63,                    //  5845:    decode to VADD_B using decoder 63
                                             //  5845:   }
  5, 4,                                      //  5849:   case 0x5: {
  OPC_Decode, 190, 7, 63,                    //  5851:    decode to VADD_H using decoder 63
                                             //  5851:   }
  6, 4,                                      //  5855:   case 0x6: {
  OPC_Decode, 192, 7, 63,                    //  5857:    decode to VADD_W using decoder 63
                                             //  5857:   }
  7, 0,                                      //  5861:   case 0x7: {
  OPC_Decode, 189, 7, 63,                    //  5863:    decode to VADD_D using decoder 63
                                             //  5863:   }
                                             //  5863:   } // switch Inst[17:15]
                                             //  5863:  }
  3, 27,                                     //  5867:  case 0x3: {
  OPC_SwitchField, 15, 3,                    //  5869:   switch Inst[17:15] {
  0, 4,                                      //  5872:   case 0x0: {
  OPC_Decode, 229, 12, 63,                   //  5874:    decode to VSUB_B using decoder 63
                                             //  5874:   }
  1, 4,                                      //  5878:   case 0x1: {
  OPC_Decode, 231, 12, 63,                   //  5880:    decode to VSUB_H using decoder 63
                                             //  5880:   }
  2, 4,                                      //  5884:   case 0x2: {
  OPC_Decode, 233, 12, 63,                   //  5886:    decode to VSUB_W using decoder 63
                                             //  5886:   }
  3, 0,                                      //  5890:   case 0x3: {
  OPC_Decode, 230, 12, 63,                   //  5892:    decode to VSUB_D using decoder 63
                                             //  5892:   }
                                             //  5892:   } // switch Inst[17:15]
                                             //  5892:  }
  7, 27,                                     //  5896:  case 0x7: {
  OPC_SwitchField, 15, 3,                    //  5898:   switch Inst[17:15] {
  4, 4,                                      //  5901:   case 0x4: {
  OPC_Decode, 167, 7, 63,                    //  5903:    decode to VADDWEV_H_B using decoder 63
                                             //  5903:   }
  5, 4,                                      //  5907:   case 0x5: {
  OPC_Decode, 173, 7, 63,                    //  5909:    decode to VADDWEV_W_H using decoder 63
                                             //  5909:   }
  6, 4,                                      //  5913:   case 0x6: {
  OPC_Decode, 164, 7, 63,                    //  5915:    decode to VADDWEV_D_W using decoder 63
                                             //  5915:   }
  7, 0,                                      //  5919:   case 0x7: {
  OPC_Decode, 170, 7, 63,                    //  5921:    decode to VADDWEV_Q_D using decoder 63
                                             //  5921:   }
                                             //  5921:   } // switch Inst[17:15]
                                             //  5921:  }
  8, 51,                                     //  5925:  case 0x8: {
  OPC_SwitchField, 15, 3,                    //  5927:   switch Inst[17:15] {
  0, 4,                                      //  5930:   case 0x0: {
  OPC_Decode, 215, 12, 63,                   //  5932:    decode to VSUBWEV_H_B using decoder 63
                                             //  5932:   }
  1, 4,                                      //  5936:   case 0x1: {
  OPC_Decode, 219, 12, 63,                   //  5938:    decode to VSUBWEV_W_H using decoder 63
                                             //  5938:   }
  2, 4,                                      //  5942:   case 0x2: {
  OPC_Decode, 213, 12, 63,                   //  5944:    decode to VSUBWEV_D_W using decoder 63
                                             //  5944:   }
  3, 4,                                      //  5948:   case 0x3: {
  OPC_Decode, 217, 12, 63,                   //  5950:    decode to VSUBWEV_Q_D using decoder 63
                                             //  5950:   }
  4, 4,                                      //  5954:   case 0x4: {
  OPC_Decode, 179, 7, 63,                    //  5956:    decode to VADDWOD_H_B using decoder 63
                                             //  5956:   }
  5, 4,                                      //  5960:   case 0x5: {
  OPC_Decode, 185, 7, 63,                    //  5962:    decode to VADDWOD_W_H using decoder 63
                                             //  5962:   }
  6, 4,                                      //  5966:   case 0x6: {
  OPC_Decode, 176, 7, 63,                    //  5968:    decode to VADDWOD_D_W using decoder 63
                                             //  5968:   }
  7, 0,                                      //  5972:   case 0x7: {
  OPC_Decode, 182, 7, 63,                    //  5974:    decode to VADDWOD_Q_D using decoder 63
                                             //  5974:   }
                                             //  5974:   } // switch Inst[17:15]
                                             //  5974:  }
  9, 27,                                     //  5978:  case 0x9: {
  OPC_SwitchField, 15, 3,                    //  5980:   switch Inst[17:15] {
  0, 4,                                      //  5983:   case 0x0: {
  OPC_Decode, 223, 12, 63,                   //  5985:    decode to VSUBWOD_H_B using decoder 63
                                             //  5985:   }
  1, 4,                                      //  5989:   case 0x1: {
  OPC_Decode, 227, 12, 63,                   //  5991:    decode to VSUBWOD_W_H using decoder 63
                                             //  5991:   }
  2, 4,                                      //  5995:   case 0x2: {
  OPC_Decode, 221, 12, 63,                   //  5997:    decode to VSUBWOD_D_W using decoder 63
                                             //  5997:   }
  3, 0,                                      //  6001:   case 0x3: {
  OPC_Decode, 225, 12, 63,                   //  6003:    decode to VSUBWOD_Q_D using decoder 63
                                             //  6003:   }
                                             //  6003:   } // switch Inst[17:15]
                                             //  6003:  }
  11, 27,                                    //  6007:  case 0xb: {
  OPC_SwitchField, 15, 3,                    //  6009:   switch Inst[17:15] {
  4, 4,                                      //  6012:   case 0x4: {
  OPC_Decode, 168, 7, 63,                    //  6014:    decode to VADDWEV_H_BU using decoder 63
                                             //  6014:   }
  5, 4,                                      //  6018:   case 0x5: {
  OPC_Decode, 174, 7, 63,                    //  6020:    decode to VADDWEV_W_HU using decoder 63
                                             //  6020:   }
  6, 4,                                      //  6024:   case 0x6: {
  OPC_Decode, 165, 7, 63,                    //  6026:    decode to VADDWEV_D_WU using decoder 63
                                             //  6026:   }
  7, 0,                                      //  6030:   case 0x7: {
  OPC_Decode, 171, 7, 63,                    //  6032:    decode to VADDWEV_Q_DU using decoder 63
                                             //  6032:   }
                                             //  6032:   } // switch Inst[17:15]
                                             //  6032:  }
  12, 51,                                    //  6036:  case 0xc: {
  OPC_SwitchField, 15, 3,                    //  6038:   switch Inst[17:15] {
  0, 4,                                      //  6041:   case 0x0: {
  OPC_Decode, 216, 12, 63,                   //  6043:    decode to VSUBWEV_H_BU using decoder 63
                                             //  6043:   }
  1, 4,                                      //  6047:   case 0x1: {
  OPC_Decode, 220, 12, 63,                   //  6049:    decode to VSUBWEV_W_HU using decoder 63
                                             //  6049:   }
  2, 4,                                      //  6053:   case 0x2: {
  OPC_Decode, 214, 12, 63,                   //  6055:    decode to VSUBWEV_D_WU using decoder 63
                                             //  6055:   }
  3, 4,                                      //  6059:   case 0x3: {
  OPC_Decode, 218, 12, 63,                   //  6061:    decode to VSUBWEV_Q_DU using decoder 63
                                             //  6061:   }
  4, 4,                                      //  6065:   case 0x4: {
  OPC_Decode, 180, 7, 63,                    //  6067:    decode to VADDWOD_H_BU using decoder 63
                                             //  6067:   }
  5, 4,                                      //  6071:   case 0x5: {
  OPC_Decode, 186, 7, 63,                    //  6073:    decode to VADDWOD_W_HU using decoder 63
                                             //  6073:   }
  6, 4,                                      //  6077:   case 0x6: {
  OPC_Decode, 177, 7, 63,                    //  6079:    decode to VADDWOD_D_WU using decoder 63
                                             //  6079:   }
  7, 0,                                      //  6083:   case 0x7: {
  OPC_Decode, 183, 7, 63,                    //  6085:    decode to VADDWOD_Q_DU using decoder 63
                                             //  6085:   }
                                             //  6085:   } // switch Inst[17:15]
                                             //  6085:  }
  13, 27,                                    //  6089:  case 0xd: {
  OPC_SwitchField, 15, 3,                    //  6091:   switch Inst[17:15] {
  0, 4,                                      //  6094:   case 0x0: {
  OPC_Decode, 224, 12, 63,                   //  6096:    decode to VSUBWOD_H_BU using decoder 63
                                             //  6096:   }
  1, 4,                                      //  6100:   case 0x1: {
  OPC_Decode, 228, 12, 63,                   //  6102:    decode to VSUBWOD_W_HU using decoder 63
                                             //  6102:   }
  2, 4,                                      //  6106:   case 0x2: {
  OPC_Decode, 222, 12, 63,                   //  6108:    decode to VSUBWOD_D_WU using decoder 63
                                             //  6108:   }
  3, 0,                                      //  6112:   case 0x3: {
  OPC_Decode, 226, 12, 63,                   //  6114:    decode to VSUBWOD_Q_DU using decoder 63
                                             //  6114:   }
                                             //  6114:   } // switch Inst[17:15]
                                             //  6114:  }
  15, 27,                                    //  6118:  case 0xf: {
  OPC_SwitchField, 15, 3,                    //  6120:   switch Inst[17:15] {
  4, 4,                                      //  6123:   case 0x4: {
  OPC_Decode, 169, 7, 63,                    //  6125:    decode to VADDWEV_H_BU_B using decoder 63
                                             //  6125:   }
  5, 4,                                      //  6129:   case 0x5: {
  OPC_Decode, 175, 7, 63,                    //  6131:    decode to VADDWEV_W_HU_H using decoder 63
                                             //  6131:   }
  6, 4,                                      //  6135:   case 0x6: {
  OPC_Decode, 166, 7, 63,                    //  6137:    decode to VADDWEV_D_WU_W using decoder 63
                                             //  6137:   }
  7, 0,                                      //  6141:   case 0x7: {
  OPC_Decode, 172, 7, 63,                    //  6143:    decode to VADDWEV_Q_DU_D using decoder 63
                                             //  6143:   }
                                             //  6143:   } // switch Inst[17:15]
                                             //  6143:  }
  16, 27,                                    //  6147:  case 0x10: {
  OPC_SwitchField, 15, 3,                    //  6149:   switch Inst[17:15] {
  0, 4,                                      //  6152:   case 0x0: {
  OPC_Decode, 181, 7, 63,                    //  6154:    decode to VADDWOD_H_BU_B using decoder 63
                                             //  6154:   }
  1, 4,                                      //  6158:   case 0x1: {
  OPC_Decode, 187, 7, 63,                    //  6160:    decode to VADDWOD_W_HU_H using decoder 63
                                             //  6160:   }
  2, 4,                                      //  6164:   case 0x2: {
  OPC_Decode, 178, 7, 63,                    //  6166:    decode to VADDWOD_D_WU_W using decoder 63
                                             //  6166:   }
  3, 0,                                      //  6170:   case 0x3: {
  OPC_Decode, 184, 7, 63,                    //  6172:    decode to VADDWOD_Q_DU_D using decoder 63
                                             //  6172:   }
                                             //  6172:   } // switch Inst[17:15]
                                             //  6172:  }
  17, 27,                                    //  6176:  case 0x11: {
  OPC_SwitchField, 15, 3,                    //  6178:   switch Inst[17:15] {
  4, 4,                                      //  6181:   case 0x4: {
  OPC_Decode, 243, 10, 63,                   //  6183:    decode to VSADD_B using decoder 63
                                             //  6183:   }
  5, 4,                                      //  6187:   case 0x5: {
  OPC_Decode, 247, 10, 63,                   //  6189:    decode to VSADD_H using decoder 63
                                             //  6189:   }
  6, 4,                                      //  6193:   case 0x6: {
  OPC_Decode, 249, 10, 63,                   //  6195:    decode to VSADD_W using decoder 63
                                             //  6195:   }
  7, 0,                                      //  6199:   case 0x7: {
  OPC_Decode, 245, 10, 63,                   //  6201:    decode to VSADD_D using decoder 63
                                             //  6201:   }
                                             //  6201:   } // switch Inst[17:15]
                                             //  6201:  }
  18, 51,                                    //  6205:  case 0x12: {
  OPC_SwitchField, 15, 3,                    //  6207:   switch Inst[17:15] {
  0, 4,                                      //  6210:   case 0x0: {
  OPC_Decode, 195, 12, 63,                   //  6212:    decode to VSSUB_B using decoder 63
                                             //  6212:   }
  1, 4,                                      //  6216:   case 0x1: {
  OPC_Decode, 199, 12, 63,                   //  6218:    decode to VSSUB_H using decoder 63
                                             //  6218:   }
  2, 4,                                      //  6222:   case 0x2: {
  OPC_Decode, 201, 12, 63,                   //  6224:    decode to VSSUB_W using decoder 63
                                             //  6224:   }
  3, 4,                                      //  6228:   case 0x3: {
  OPC_Decode, 197, 12, 63,                   //  6230:    decode to VSSUB_D using decoder 63
                                             //  6230:   }
  4, 4,                                      //  6234:   case 0x4: {
  OPC_Decode, 244, 10, 63,                   //  6236:    decode to VSADD_BU using decoder 63
                                             //  6236:   }
  5, 4,                                      //  6240:   case 0x5: {
  OPC_Decode, 248, 10, 63,                   //  6242:    decode to VSADD_HU using decoder 63
                                             //  6242:   }
  6, 4,                                      //  6246:   case 0x6: {
  OPC_Decode, 250, 10, 63,                   //  6248:    decode to VSADD_WU using decoder 63
                                             //  6248:   }
  7, 0,                                      //  6252:   case 0x7: {
  OPC_Decode, 246, 10, 63,                   //  6254:    decode to VSADD_DU using decoder 63
                                             //  6254:   }
                                             //  6254:   } // switch Inst[17:15]
                                             //  6254:  }
  19, 27,                                    //  6258:  case 0x13: {
  OPC_SwitchField, 15, 3,                    //  6260:   switch Inst[17:15] {
  0, 4,                                      //  6263:   case 0x0: {
  OPC_Decode, 196, 12, 63,                   //  6265:    decode to VSSUB_BU using decoder 63
                                             //  6265:   }
  1, 4,                                      //  6269:   case 0x1: {
  OPC_Decode, 200, 12, 63,                   //  6271:    decode to VSSUB_HU using decoder 63
                                             //  6271:   }
  2, 4,                                      //  6275:   case 0x2: {
  OPC_Decode, 202, 12, 63,                   //  6277:    decode to VSSUB_WU using decoder 63
                                             //  6277:   }
  3, 0,                                      //  6281:   case 0x3: {
  OPC_Decode, 198, 12, 63,                   //  6283:    decode to VSSUB_DU using decoder 63
                                             //  6283:   }
                                             //  6283:   } // switch Inst[17:15]
                                             //  6283:  }
  21, 51,                                    //  6287:  case 0x15: {
  OPC_SwitchField, 15, 3,                    //  6289:   switch Inst[17:15] {
  0, 4,                                      //  6292:   case 0x0: {
  OPC_Decode, 167, 9, 63,                    //  6294:    decode to VHADDW_H_B using decoder 63
                                             //  6294:   }
  1, 4,                                      //  6298:   case 0x1: {
  OPC_Decode, 171, 9, 63,                    //  6300:    decode to VHADDW_W_H using decoder 63
                                             //  6300:   }
  2, 4,                                      //  6304:   case 0x2: {
  OPC_Decode, 165, 9, 63,                    //  6306:    decode to VHADDW_D_W using decoder 63
                                             //  6306:   }
  3, 4,                                      //  6310:   case 0x3: {
  OPC_Decode, 169, 9, 63,                    //  6312:    decode to VHADDW_Q_D using decoder 63
                                             //  6312:   }
  4, 4,                                      //  6316:   case 0x4: {
  OPC_Decode, 175, 9, 63,                    //  6318:    decode to VHSUBW_H_B using decoder 63
                                             //  6318:   }
  5, 4,                                      //  6322:   case 0x5: {
  OPC_Decode, 179, 9, 63,                    //  6324:    decode to VHSUBW_W_H using decoder 63
                                             //  6324:   }
  6, 4,                                      //  6328:   case 0x6: {
  OPC_Decode, 173, 9, 63,                    //  6330:    decode to VHSUBW_D_W using decoder 63
                                             //  6330:   }
  7, 0,                                      //  6334:   case 0x7: {
  OPC_Decode, 177, 9, 63,                    //  6336:    decode to VHSUBW_Q_D using decoder 63
                                             //  6336:   }
                                             //  6336:   } // switch Inst[17:15]
                                             //  6336:  }
  22, 51,                                    //  6340:  case 0x16: {
  OPC_SwitchField, 15, 3,                    //  6342:   switch Inst[17:15] {
  0, 4,                                      //  6345:   case 0x0: {
  OPC_Decode, 166, 9, 63,                    //  6347:    decode to VHADDW_HU_BU using decoder 63
                                             //  6347:   }
  1, 4,                                      //  6351:   case 0x1: {
  OPC_Decode, 170, 9, 63,                    //  6353:    decode to VHADDW_WU_HU using decoder 63
                                             //  6353:   }
  2, 4,                                      //  6357:   case 0x2: {
  OPC_Decode, 164, 9, 63,                    //  6359:    decode to VHADDW_DU_WU using decoder 63
                                             //  6359:   }
  3, 4,                                      //  6363:   case 0x3: {
  OPC_Decode, 168, 9, 63,                    //  6365:    decode to VHADDW_QU_DU using decoder 63
                                             //  6365:   }
  4, 4,                                      //  6369:   case 0x4: {
  OPC_Decode, 174, 9, 63,                    //  6371:    decode to VHSUBW_HU_BU using decoder 63
                                             //  6371:   }
  5, 4,                                      //  6375:   case 0x5: {
  OPC_Decode, 178, 9, 63,                    //  6377:    decode to VHSUBW_WU_HU using decoder 63
                                             //  6377:   }
  6, 4,                                      //  6381:   case 0x6: {
  OPC_Decode, 172, 9, 63,                    //  6383:    decode to VHSUBW_DU_WU using decoder 63
                                             //  6383:   }
  7, 0,                                      //  6387:   case 0x7: {
  OPC_Decode, 176, 9, 63,                    //  6389:    decode to VHSUBW_QU_DU using decoder 63
                                             //  6389:   }
                                             //  6389:   } // switch Inst[17:15]
                                             //  6389:  }
  23, 27,                                    //  6393:  case 0x17: {
  OPC_SwitchField, 15, 3,                    //  6395:   switch Inst[17:15] {
  0, 4,                                      //  6398:   case 0x0: {
  OPC_Decode, 156, 7, 63,                    //  6400:    decode to VADDA_B using decoder 63
                                             //  6400:   }
  1, 4,                                      //  6404:   case 0x1: {
  OPC_Decode, 158, 7, 63,                    //  6406:    decode to VADDA_H using decoder 63
                                             //  6406:   }
  2, 4,                                      //  6410:   case 0x2: {
  OPC_Decode, 159, 7, 63,                    //  6412:    decode to VADDA_W using decoder 63
                                             //  6412:   }
  3, 0,                                      //  6416:   case 0x3: {
  OPC_Decode, 157, 7, 63,                    //  6418:    decode to VADDA_D using decoder 63
                                             //  6418:   }
                                             //  6418:   } // switch Inst[17:15]
                                             //  6418:  }
  24, 51,                                    //  6422:  case 0x18: {
  OPC_SwitchField, 15, 3,                    //  6424:   switch Inst[17:15] {
  0, 4,                                      //  6427:   case 0x0: {
  OPC_Decode, 148, 7, 63,                    //  6429:    decode to VABSD_B using decoder 63
                                             //  6429:   }
  1, 4,                                      //  6433:   case 0x1: {
  OPC_Decode, 152, 7, 63,                    //  6435:    decode to VABSD_H using decoder 63
                                             //  6435:   }
  2, 4,                                      //  6439:   case 0x2: {
  OPC_Decode, 154, 7, 63,                    //  6441:    decode to VABSD_W using decoder 63
                                             //  6441:   }
  3, 4,                                      //  6445:   case 0x3: {
  OPC_Decode, 150, 7, 63,                    //  6447:    decode to VABSD_D using decoder 63
                                             //  6447:   }
  4, 4,                                      //  6451:   case 0x4: {
  OPC_Decode, 149, 7, 63,                    //  6453:    decode to VABSD_BU using decoder 63
                                             //  6453:   }
  5, 4,                                      //  6457:   case 0x5: {
  OPC_Decode, 153, 7, 63,                    //  6459:    decode to VABSD_HU using decoder 63
                                             //  6459:   }
  6, 4,                                      //  6463:   case 0x6: {
  OPC_Decode, 155, 7, 63,                    //  6465:    decode to VABSD_WU using decoder 63
                                             //  6465:   }
  7, 0,                                      //  6469:   case 0x7: {
  OPC_Decode, 151, 7, 63,                    //  6471:    decode to VABSD_DU using decoder 63
                                             //  6471:   }
                                             //  6471:   } // switch Inst[17:15]
                                             //  6471:  }
  25, 51,                                    //  6475:  case 0x19: {
  OPC_SwitchField, 15, 3,                    //  6477:   switch Inst[17:15] {
  0, 4,                                      //  6480:   case 0x0: {
  OPC_Decode, 204, 7, 63,                    //  6482:    decode to VAVG_B using decoder 63
                                             //  6482:   }
  1, 4,                                      //  6486:   case 0x1: {
  OPC_Decode, 208, 7, 63,                    //  6488:    decode to VAVG_H using decoder 63
                                             //  6488:   }
  2, 4,                                      //  6492:   case 0x2: {
  OPC_Decode, 210, 7, 63,                    //  6494:    decode to VAVG_W using decoder 63
                                             //  6494:   }
  3, 4,                                      //  6498:   case 0x3: {
  OPC_Decode, 206, 7, 63,                    //  6500:    decode to VAVG_D using decoder 63
                                             //  6500:   }
  4, 4,                                      //  6504:   case 0x4: {
  OPC_Decode, 205, 7, 63,                    //  6506:    decode to VAVG_BU using decoder 63
                                             //  6506:   }
  5, 4,                                      //  6510:   case 0x5: {
  OPC_Decode, 209, 7, 63,                    //  6512:    decode to VAVG_HU using decoder 63
                                             //  6512:   }
  6, 4,                                      //  6516:   case 0x6: {
  OPC_Decode, 211, 7, 63,                    //  6518:    decode to VAVG_WU using decoder 63
                                             //  6518:   }
  7, 0,                                      //  6522:   case 0x7: {
  OPC_Decode, 207, 7, 63,                    //  6524:    decode to VAVG_DU using decoder 63
                                             //  6524:   }
                                             //  6524:   } // switch Inst[17:15]
                                             //  6524:  }
  26, 51,                                    //  6528:  case 0x1a: {
  OPC_SwitchField, 15, 3,                    //  6530:   switch Inst[17:15] {
  0, 4,                                      //  6533:   case 0x0: {
  OPC_Decode, 196, 7, 63,                    //  6535:    decode to VAVGR_B using decoder 63
                                             //  6535:   }
  1, 4,                                      //  6539:   case 0x1: {
  OPC_Decode, 200, 7, 63,                    //  6541:    decode to VAVGR_H using decoder 63
                                             //  6541:   }
  2, 4,                                      //  6545:   case 0x2: {
  OPC_Decode, 202, 7, 63,                    //  6547:    decode to VAVGR_W using decoder 63
                                             //  6547:   }
  3, 4,                                      //  6551:   case 0x3: {
  OPC_Decode, 198, 7, 63,                    //  6553:    decode to VAVGR_D using decoder 63
                                             //  6553:   }
  4, 4,                                      //  6557:   case 0x4: {
  OPC_Decode, 197, 7, 63,                    //  6559:    decode to VAVGR_BU using decoder 63
                                             //  6559:   }
  5, 4,                                      //  6563:   case 0x5: {
  OPC_Decode, 201, 7, 63,                    //  6565:    decode to VAVGR_HU using decoder 63
                                             //  6565:   }
  6, 4,                                      //  6569:   case 0x6: {
  OPC_Decode, 203, 7, 63,                    //  6571:    decode to VAVGR_WU using decoder 63
                                             //  6571:   }
  7, 0,                                      //  6575:   case 0x7: {
  OPC_Decode, 199, 7, 63,                    //  6577:    decode to VAVGR_DU using decoder 63
                                             //  6577:   }
                                             //  6577:   } // switch Inst[17:15]
                                             //  6577:  }
  28, 51,                                    //  6581:  case 0x1c: {
  OPC_SwitchField, 15, 3,                    //  6583:   switch Inst[17:15] {
  0, 4,                                      //  6586:   case 0x0: {
  OPC_Decode, 235, 9, 63,                    //  6588:    decode to VMAX_B using decoder 63
                                             //  6588:   }
  1, 4,                                      //  6592:   case 0x1: {
  OPC_Decode, 239, 9, 63,                    //  6594:    decode to VMAX_H using decoder 63
                                             //  6594:   }
  2, 4,                                      //  6598:   case 0x2: {
  OPC_Decode, 241, 9, 63,                    //  6600:    decode to VMAX_W using decoder 63
                                             //  6600:   }
  3, 4,                                      //  6604:   case 0x3: {
  OPC_Decode, 237, 9, 63,                    //  6606:    decode to VMAX_D using decoder 63
                                             //  6606:   }
  4, 4,                                      //  6610:   case 0x4: {
  OPC_Decode, 251, 9, 63,                    //  6612:    decode to VMIN_B using decoder 63
                                             //  6612:   }
  5, 4,                                      //  6616:   case 0x5: {
  OPC_Decode, 255, 9, 63,                    //  6618:    decode to VMIN_H using decoder 63
                                             //  6618:   }
  6, 4,                                      //  6622:   case 0x6: {
  OPC_Decode, 129, 10, 63,                   //  6624:    decode to VMIN_W using decoder 63
                                             //  6624:   }
  7, 0,                                      //  6628:   case 0x7: {
  OPC_Decode, 253, 9, 63,                    //  6630:    decode to VMIN_D using decoder 63
                                             //  6630:   }
                                             //  6630:   } // switch Inst[17:15]
                                             //  6630:  }
  29, 51,                                    //  6634:  case 0x1d: {
  OPC_SwitchField, 15, 3,                    //  6636:   switch Inst[17:15] {
  0, 4,                                      //  6639:   case 0x0: {
  OPC_Decode, 236, 9, 63,                    //  6641:    decode to VMAX_BU using decoder 63
                                             //  6641:   }
  1, 4,                                      //  6645:   case 0x1: {
  OPC_Decode, 240, 9, 63,                    //  6647:    decode to VMAX_HU using decoder 63
                                             //  6647:   }
  2, 4,                                      //  6651:   case 0x2: {
  OPC_Decode, 242, 9, 63,                    //  6653:    decode to VMAX_WU using decoder 63
                                             //  6653:   }
  3, 4,                                      //  6657:   case 0x3: {
  OPC_Decode, 238, 9, 63,                    //  6659:    decode to VMAX_DU using decoder 63
                                             //  6659:   }
  4, 4,                                      //  6663:   case 0x4: {
  OPC_Decode, 252, 9, 63,                    //  6665:    decode to VMIN_BU using decoder 63
                                             //  6665:   }
  5, 4,                                      //  6669:   case 0x5: {
  OPC_Decode, 128, 10, 63,                   //  6671:    decode to VMIN_HU using decoder 63
                                             //  6671:   }
  6, 4,                                      //  6675:   case 0x6: {
  OPC_Decode, 130, 10, 63,                   //  6677:    decode to VMIN_WU using decoder 63
                                             //  6677:   }
  7, 0,                                      //  6681:   case 0x7: {
  OPC_Decode, 254, 9, 63,                    //  6683:    decode to VMIN_DU using decoder 63
                                             //  6683:   }
                                             //  6683:   } // switch Inst[17:15]
                                             //  6683:  }
  33, 51,                                    //  6687:  case 0x21: {
  OPC_SwitchField, 15, 3,                    //  6689:   switch Inst[17:15] {
  0, 4,                                      //  6692:   case 0x0: {
  OPC_Decode, 181, 10, 63,                   //  6694:    decode to VMUL_B using decoder 63
                                             //  6694:   }
  1, 4,                                      //  6698:   case 0x1: {
  OPC_Decode, 183, 10, 63,                   //  6700:    decode to VMUL_H using decoder 63
                                             //  6700:   }
  2, 4,                                      //  6704:   case 0x2: {
  OPC_Decode, 184, 10, 63,                   //  6706:    decode to VMUL_W using decoder 63
                                             //  6706:   }
  3, 4,                                      //  6710:   case 0x3: {
  OPC_Decode, 182, 10, 63,                   //  6712:    decode to VMUL_D using decoder 63
                                             //  6712:   }
  4, 4,                                      //  6716:   case 0x4: {
  OPC_Decode, 149, 10, 63,                   //  6718:    decode to VMUH_B using decoder 63
                                             //  6718:   }
  5, 4,                                      //  6722:   case 0x5: {
  OPC_Decode, 153, 10, 63,                   //  6724:    decode to VMUH_H using decoder 63
                                             //  6724:   }
  6, 4,                                      //  6728:   case 0x6: {
  OPC_Decode, 155, 10, 63,                   //  6730:    decode to VMUH_W using decoder 63
                                             //  6730:   }
  7, 0,                                      //  6734:   case 0x7: {
  OPC_Decode, 151, 10, 63,                   //  6736:    decode to VMUH_D using decoder 63
                                             //  6736:   }
                                             //  6736:   } // switch Inst[17:15]
                                             //  6736:  }
  34, 27,                                    //  6740:  case 0x22: {
  OPC_SwitchField, 15, 3,                    //  6742:   switch Inst[17:15] {
  0, 4,                                      //  6745:   case 0x0: {
  OPC_Decode, 150, 10, 63,                   //  6747:    decode to VMUH_BU using decoder 63
                                             //  6747:   }
  1, 4,                                      //  6751:   case 0x1: {
  OPC_Decode, 154, 10, 63,                   //  6753:    decode to VMUH_HU using decoder 63
                                             //  6753:   }
  2, 4,                                      //  6757:   case 0x2: {
  OPC_Decode, 156, 10, 63,                   //  6759:    decode to VMUH_WU using decoder 63
                                             //  6759:   }
  3, 0,                                      //  6763:   case 0x3: {
  OPC_Decode, 152, 10, 63,                   //  6765:    decode to VMUH_DU using decoder 63
                                             //  6765:   }
                                             //  6765:   } // switch Inst[17:15]
                                             //  6765:  }
  36, 51,                                    //  6769:  case 0x24: {
  OPC_SwitchField, 15, 3,                    //  6771:   switch Inst[17:15] {
  0, 4,                                      //  6774:   case 0x0: {
  OPC_Decode, 160, 10, 63,                   //  6776:    decode to VMULWEV_H_B using decoder 63
                                             //  6776:   }
  1, 4,                                      //  6780:   case 0x1: {
  OPC_Decode, 166, 10, 63,                   //  6782:    decode to VMULWEV_W_H using decoder 63
                                             //  6782:   }
  2, 4,                                      //  6786:   case 0x2: {
  OPC_Decode, 157, 10, 63,                   //  6788:    decode to VMULWEV_D_W using decoder 63
                                             //  6788:   }
  3, 4,                                      //  6792:   case 0x3: {
  OPC_Decode, 163, 10, 63,                   //  6794:    decode to VMULWEV_Q_D using decoder 63
                                             //  6794:   }
  4, 4,                                      //  6798:   case 0x4: {
  OPC_Decode, 172, 10, 63,                   //  6800:    decode to VMULWOD_H_B using decoder 63
                                             //  6800:   }
  5, 4,                                      //  6804:   case 0x5: {
  OPC_Decode, 178, 10, 63,                   //  6806:    decode to VMULWOD_W_H using decoder 63
                                             //  6806:   }
  6, 4,                                      //  6810:   case 0x6: {
  OPC_Decode, 169, 10, 63,                   //  6812:    decode to VMULWOD_D_W using decoder 63
                                             //  6812:   }
  7, 0,                                      //  6816:   case 0x7: {
  OPC_Decode, 175, 10, 63,                   //  6818:    decode to VMULWOD_Q_D using decoder 63
                                             //  6818:   }
                                             //  6818:   } // switch Inst[17:15]
                                             //  6818:  }
  38, 51,                                    //  6822:  case 0x26: {
  OPC_SwitchField, 15, 3,                    //  6824:   switch Inst[17:15] {
  0, 4,                                      //  6827:   case 0x0: {
  OPC_Decode, 161, 10, 63,                   //  6829:    decode to VMULWEV_H_BU using decoder 63
                                             //  6829:   }
  1, 4,                                      //  6833:   case 0x1: {
  OPC_Decode, 167, 10, 63,                   //  6835:    decode to VMULWEV_W_HU using decoder 63
                                             //  6835:   }
  2, 4,                                      //  6839:   case 0x2: {
  OPC_Decode, 158, 10, 63,                   //  6841:    decode to VMULWEV_D_WU using decoder 63
                                             //  6841:   }
  3, 4,                                      //  6845:   case 0x3: {
  OPC_Decode, 164, 10, 63,                   //  6847:    decode to VMULWEV_Q_DU using decoder 63
                                             //  6847:   }
  4, 4,                                      //  6851:   case 0x4: {
  OPC_Decode, 173, 10, 63,                   //  6853:    decode to VMULWOD_H_BU using decoder 63
                                             //  6853:   }
  5, 4,                                      //  6857:   case 0x5: {
  OPC_Decode, 179, 10, 63,                   //  6859:    decode to VMULWOD_W_HU using decoder 63
                                             //  6859:   }
  6, 4,                                      //  6863:   case 0x6: {
  OPC_Decode, 170, 10, 63,                   //  6865:    decode to VMULWOD_D_WU using decoder 63
                                             //  6865:   }
  7, 0,                                      //  6869:   case 0x7: {
  OPC_Decode, 176, 10, 63,                   //  6871:    decode to VMULWOD_Q_DU using decoder 63
                                             //  6871:   }
                                             //  6871:   } // switch Inst[17:15]
                                             //  6871:  }
  40, 51,                                    //  6875:  case 0x28: {
  OPC_SwitchField, 15, 3,                    //  6877:   switch Inst[17:15] {
  0, 4,                                      //  6880:   case 0x0: {
  OPC_Decode, 162, 10, 63,                   //  6882:    decode to VMULWEV_H_BU_B using decoder 63
                                             //  6882:   }
  1, 4,                                      //  6886:   case 0x1: {
  OPC_Decode, 168, 10, 63,                   //  6888:    decode to VMULWEV_W_HU_H using decoder 63
                                             //  6888:   }
  2, 4,                                      //  6892:   case 0x2: {
  OPC_Decode, 159, 10, 63,                   //  6894:    decode to VMULWEV_D_WU_W using decoder 63
                                             //  6894:   }
  3, 4,                                      //  6898:   case 0x3: {
  OPC_Decode, 165, 10, 63,                   //  6900:    decode to VMULWEV_Q_DU_D using decoder 63
                                             //  6900:   }
  4, 4,                                      //  6904:   case 0x4: {
  OPC_Decode, 174, 10, 63,                   //  6906:    decode to VMULWOD_H_BU_B using decoder 63
                                             //  6906:   }
  5, 4,                                      //  6910:   case 0x5: {
  OPC_Decode, 180, 10, 63,                   //  6912:    decode to VMULWOD_W_HU_H using decoder 63
                                             //  6912:   }
  6, 4,                                      //  6916:   case 0x6: {
  OPC_Decode, 171, 10, 63,                   //  6918:    decode to VMULWOD_D_WU_W using decoder 63
                                             //  6918:   }
  7, 0,                                      //  6922:   case 0x7: {
  OPC_Decode, 177, 10, 63,                   //  6924:    decode to VMULWOD_Q_DU_D using decoder 63
                                             //  6924:   }
                                             //  6924:   } // switch Inst[17:15]
                                             //  6924:  }
  42, 51,                                    //  6928:  case 0x2a: {
  OPC_SwitchField, 15, 3,                    //  6930:   switch Inst[17:15] {
  0, 4,                                      //  6933:   case 0x0: {
  OPC_Decode, 223, 9, 104,                   //  6935:    decode to VMADD_B using decoder 104
                                             //  6935:   }
  1, 4,                                      //  6939:   case 0x1: {
  OPC_Decode, 225, 9, 104,                   //  6941:    decode to VMADD_H using decoder 104
                                             //  6941:   }
  2, 4,                                      //  6945:   case 0x2: {
  OPC_Decode, 226, 9, 104,                   //  6947:    decode to VMADD_W using decoder 104
                                             //  6947:   }
  3, 4,                                      //  6951:   case 0x3: {
  OPC_Decode, 224, 9, 104,                   //  6953:    decode to VMADD_D using decoder 104
                                             //  6953:   }
  4, 4,                                      //  6957:   case 0x4: {
  OPC_Decode, 145, 10, 104,                  //  6959:    decode to VMSUB_B using decoder 104
                                             //  6959:   }
  5, 4,                                      //  6963:   case 0x5: {
  OPC_Decode, 147, 10, 104,                  //  6965:    decode to VMSUB_H using decoder 104
                                             //  6965:   }
  6, 4,                                      //  6969:   case 0x6: {
  OPC_Decode, 148, 10, 104,                  //  6971:    decode to VMSUB_W using decoder 104
                                             //  6971:   }
  7, 0,                                      //  6975:   case 0x7: {
  OPC_Decode, 146, 10, 104,                  //  6977:    decode to VMSUB_D using decoder 104
                                             //  6977:   }
                                             //  6977:   } // switch Inst[17:15]
                                             //  6977:  }
  43, 51,                                    //  6981:  case 0x2b: {
  OPC_SwitchField, 15, 3,                    //  6983:   switch Inst[17:15] {
  0, 4,                                      //  6986:   case 0x0: {
  OPC_Decode, 202, 9, 104,                   //  6988:    decode to VMADDWEV_H_B using decoder 104
                                             //  6988:   }
  1, 4,                                      //  6992:   case 0x1: {
  OPC_Decode, 208, 9, 104,                   //  6994:    decode to VMADDWEV_W_H using decoder 104
                                             //  6994:   }
  2, 4,                                      //  6998:   case 0x2: {
  OPC_Decode, 199, 9, 104,                   //  7000:    decode to VMADDWEV_D_W using decoder 104
                                             //  7000:   }
  3, 4,                                      //  7004:   case 0x3: {
  OPC_Decode, 205, 9, 104,                   //  7006:    decode to VMADDWEV_Q_D using decoder 104
                                             //  7006:   }
  4, 4,                                      //  7010:   case 0x4: {
  OPC_Decode, 214, 9, 104,                   //  7012:    decode to VMADDWOD_H_B using decoder 104
                                             //  7012:   }
  5, 4,                                      //  7016:   case 0x5: {
  OPC_Decode, 220, 9, 104,                   //  7018:    decode to VMADDWOD_W_H using decoder 104
                                             //  7018:   }
  6, 4,                                      //  7022:   case 0x6: {
  OPC_Decode, 211, 9, 104,                   //  7024:    decode to VMADDWOD_D_W using decoder 104
                                             //  7024:   }
  7, 0,                                      //  7028:   case 0x7: {
  OPC_Decode, 217, 9, 104,                   //  7030:    decode to VMADDWOD_Q_D using decoder 104
                                             //  7030:   }
                                             //  7030:   } // switch Inst[17:15]
                                             //  7030:  }
  45, 51,                                    //  7034:  case 0x2d: {
  OPC_SwitchField, 15, 3,                    //  7036:   switch Inst[17:15] {
  0, 4,                                      //  7039:   case 0x0: {
  OPC_Decode, 203, 9, 104,                   //  7041:    decode to VMADDWEV_H_BU using decoder 104
                                             //  7041:   }
  1, 4,                                      //  7045:   case 0x1: {
  OPC_Decode, 209, 9, 104,                   //  7047:    decode to VMADDWEV_W_HU using decoder 104
                                             //  7047:   }
  2, 4,                                      //  7051:   case 0x2: {
  OPC_Decode, 200, 9, 104,                   //  7053:    decode to VMADDWEV_D_WU using decoder 104
                                             //  7053:   }
  3, 4,                                      //  7057:   case 0x3: {
  OPC_Decode, 206, 9, 104,                   //  7059:    decode to VMADDWEV_Q_DU using decoder 104
                                             //  7059:   }
  4, 4,                                      //  7063:   case 0x4: {
  OPC_Decode, 215, 9, 104,                   //  7065:    decode to VMADDWOD_H_BU using decoder 104
                                             //  7065:   }
  5, 4,                                      //  7069:   case 0x5: {
  OPC_Decode, 221, 9, 104,                   //  7071:    decode to VMADDWOD_W_HU using decoder 104
                                             //  7071:   }
  6, 4,                                      //  7075:   case 0x6: {
  OPC_Decode, 212, 9, 104,                   //  7077:    decode to VMADDWOD_D_WU using decoder 104
                                             //  7077:   }
  7, 0,                                      //  7081:   case 0x7: {
  OPC_Decode, 218, 9, 104,                   //  7083:    decode to VMADDWOD_Q_DU using decoder 104
                                             //  7083:   }
                                             //  7083:   } // switch Inst[17:15]
                                             //  7083:  }
  47, 51,                                    //  7087:  case 0x2f: {
  OPC_SwitchField, 15, 3,                    //  7089:   switch Inst[17:15] {
  0, 4,                                      //  7092:   case 0x0: {
  OPC_Decode, 204, 9, 104,                   //  7094:    decode to VMADDWEV_H_BU_B using decoder 104
                                             //  7094:   }
  1, 4,                                      //  7098:   case 0x1: {
  OPC_Decode, 210, 9, 104,                   //  7100:    decode to VMADDWEV_W_HU_H using decoder 104
                                             //  7100:   }
  2, 4,                                      //  7104:   case 0x2: {
  OPC_Decode, 201, 9, 104,                   //  7106:    decode to VMADDWEV_D_WU_W using decoder 104
                                             //  7106:   }
  3, 4,                                      //  7110:   case 0x3: {
  OPC_Decode, 207, 9, 104,                   //  7112:    decode to VMADDWEV_Q_DU_D using decoder 104
                                             //  7112:   }
  4, 4,                                      //  7116:   case 0x4: {
  OPC_Decode, 216, 9, 104,                   //  7118:    decode to VMADDWOD_H_BU_B using decoder 104
                                             //  7118:   }
  5, 4,                                      //  7122:   case 0x5: {
  OPC_Decode, 222, 9, 104,                   //  7124:    decode to VMADDWOD_W_HU_H using decoder 104
                                             //  7124:   }
  6, 4,                                      //  7128:   case 0x6: {
  OPC_Decode, 213, 9, 104,                   //  7130:    decode to VMADDWOD_D_WU_W using decoder 104
                                             //  7130:   }
  7, 0,                                      //  7134:   case 0x7: {
  OPC_Decode, 219, 9, 104,                   //  7136:    decode to VMADDWOD_Q_DU_D using decoder 104
                                             //  7136:   }
                                             //  7136:   } // switch Inst[17:15]
                                             //  7136:  }
  56, 51,                                    //  7140:  case 0x38: {
  OPC_SwitchField, 15, 3,                    //  7142:   switch Inst[17:15] {
  0, 4,                                      //  7145:   case 0x0: {
  OPC_Decode, 248, 7, 63,                    //  7147:    decode to VDIV_B using decoder 63
                                             //  7147:   }
  1, 4,                                      //  7151:   case 0x1: {
  OPC_Decode, 252, 7, 63,                    //  7153:    decode to VDIV_H using decoder 63
                                             //  7153:   }
  2, 4,                                      //  7157:   case 0x2: {
  OPC_Decode, 254, 7, 63,                    //  7159:    decode to VDIV_W using decoder 63
                                             //  7159:   }
  3, 4,                                      //  7163:   case 0x3: {
  OPC_Decode, 250, 7, 63,                    //  7165:    decode to VDIV_D using decoder 63
                                             //  7165:   }
  4, 4,                                      //  7169:   case 0x4: {
  OPC_Decode, 131, 10, 63,                   //  7171:    decode to VMOD_B using decoder 63
                                             //  7171:   }
  5, 4,                                      //  7175:   case 0x5: {
  OPC_Decode, 135, 10, 63,                   //  7177:    decode to VMOD_H using decoder 63
                                             //  7177:   }
  6, 4,                                      //  7181:   case 0x6: {
  OPC_Decode, 137, 10, 63,                   //  7183:    decode to VMOD_W using decoder 63
                                             //  7183:   }
  7, 0,                                      //  7187:   case 0x7: {
  OPC_Decode, 133, 10, 63,                   //  7189:    decode to VMOD_D using decoder 63
                                             //  7189:   }
                                             //  7189:   } // switch Inst[17:15]
                                             //  7189:  }
  57, 51,                                    //  7193:  case 0x39: {
  OPC_SwitchField, 15, 3,                    //  7195:   switch Inst[17:15] {
  0, 4,                                      //  7198:   case 0x0: {
  OPC_Decode, 249, 7, 63,                    //  7200:    decode to VDIV_BU using decoder 63
                                             //  7200:   }
  1, 4,                                      //  7204:   case 0x1: {
  OPC_Decode, 253, 7, 63,                    //  7206:    decode to VDIV_HU using decoder 63
                                             //  7206:   }
  2, 4,                                      //  7210:   case 0x2: {
  OPC_Decode, 255, 7, 63,                    //  7212:    decode to VDIV_WU using decoder 63
                                             //  7212:   }
  3, 4,                                      //  7216:   case 0x3: {
  OPC_Decode, 251, 7, 63,                    //  7218:    decode to VDIV_DU using decoder 63
                                             //  7218:   }
  4, 4,                                      //  7222:   case 0x4: {
  OPC_Decode, 132, 10, 63,                   //  7224:    decode to VMOD_BU using decoder 63
                                             //  7224:   }
  5, 4,                                      //  7228:   case 0x5: {
  OPC_Decode, 136, 10, 63,                   //  7230:    decode to VMOD_HU using decoder 63
                                             //  7230:   }
  6, 4,                                      //  7234:   case 0x6: {
  OPC_Decode, 138, 10, 63,                   //  7236:    decode to VMOD_WU using decoder 63
                                             //  7236:   }
  7, 0,                                      //  7240:   case 0x7: {
  OPC_Decode, 134, 10, 63,                   //  7242:    decode to VMOD_DU using decoder 63
                                             //  7242:   }
                                             //  7242:   } // switch Inst[17:15]
                                             //  7242:  }
  58, 51,                                    //  7246:  case 0x3a: {
  OPC_SwitchField, 15, 3,                    //  7248:   switch Inst[17:15] {
  0, 4,                                      //  7251:   case 0x0: {
  OPC_Decode, 187, 11, 63,                   //  7253:    decode to VSLL_B using decoder 63
                                             //  7253:   }
  1, 4,                                      //  7257:   case 0x1: {
  OPC_Decode, 189, 11, 63,                   //  7259:    decode to VSLL_H using decoder 63
                                             //  7259:   }
  2, 4,                                      //  7263:   case 0x2: {
  OPC_Decode, 190, 11, 63,                   //  7265:    decode to VSLL_W using decoder 63
                                             //  7265:   }
  3, 4,                                      //  7269:   case 0x3: {
  OPC_Decode, 188, 11, 63,                   //  7271:    decode to VSLL_D using decoder 63
                                             //  7271:   }
  4, 4,                                      //  7275:   case 0x4: {
  OPC_Decode, 135, 12, 63,                   //  7277:    decode to VSRL_B using decoder 63
                                             //  7277:   }
  5, 4,                                      //  7281:   case 0x5: {
  OPC_Decode, 137, 12, 63,                   //  7283:    decode to VSRL_H using decoder 63
                                             //  7283:   }
  6, 4,                                      //  7287:   case 0x6: {
  OPC_Decode, 138, 12, 63,                   //  7289:    decode to VSRL_W using decoder 63
                                             //  7289:   }
  7, 0,                                      //  7293:   case 0x7: {
  OPC_Decode, 136, 12, 63,                   //  7295:    decode to VSRL_D using decoder 63
                                             //  7295:   }
                                             //  7295:   } // switch Inst[17:15]
                                             //  7295:  }
  59, 51,                                    //  7299:  case 0x3b: {
  OPC_SwitchField, 15, 3,                    //  7301:   switch Inst[17:15] {
  0, 4,                                      //  7304:   case 0x0: {
  OPC_Decode, 233, 11, 63,                   //  7306:    decode to VSRA_B using decoder 63
                                             //  7306:   }
  1, 4,                                      //  7310:   case 0x1: {
  OPC_Decode, 235, 11, 63,                   //  7312:    decode to VSRA_H using decoder 63
                                             //  7312:   }
  2, 4,                                      //  7316:   case 0x2: {
  OPC_Decode, 236, 11, 63,                   //  7318:    decode to VSRA_W using decoder 63
                                             //  7318:   }
  3, 4,                                      //  7322:   case 0x3: {
  OPC_Decode, 234, 11, 63,                   //  7324:    decode to VSRA_D using decoder 63
                                             //  7324:   }
  4, 4,                                      //  7328:   case 0x4: {
  OPC_Decode, 239, 10, 63,                   //  7330:    decode to VROTR_B using decoder 63
                                             //  7330:   }
  5, 4,                                      //  7334:   case 0x5: {
  OPC_Decode, 241, 10, 63,                   //  7336:    decode to VROTR_H using decoder 63
                                             //  7336:   }
  6, 4,                                      //  7340:   case 0x6: {
  OPC_Decode, 242, 10, 63,                   //  7342:    decode to VROTR_W using decoder 63
                                             //  7342:   }
  7, 0,                                      //  7346:   case 0x7: {
  OPC_Decode, 240, 10, 63,                   //  7348:    decode to VROTR_D using decoder 63
                                             //  7348:   }
                                             //  7348:   } // switch Inst[17:15]
                                             //  7348:  }
  60, 51,                                    //  7352:  case 0x3c: {
  OPC_SwitchField, 15, 3,                    //  7354:   switch Inst[17:15] {
  0, 4,                                      //  7357:   case 0x0: {
  OPC_Decode, 131, 12, 63,                   //  7359:    decode to VSRLR_B using decoder 63
                                             //  7359:   }
  1, 4,                                      //  7363:   case 0x1: {
  OPC_Decode, 133, 12, 63,                   //  7365:    decode to VSRLR_H using decoder 63
                                             //  7365:   }
  2, 4,                                      //  7369:   case 0x2: {
  OPC_Decode, 134, 12, 63,                   //  7371:    decode to VSRLR_W using decoder 63
                                             //  7371:   }
  3, 4,                                      //  7375:   case 0x3: {
  OPC_Decode, 132, 12, 63,                   //  7377:    decode to VSRLR_D using decoder 63
                                             //  7377:   }
  4, 4,                                      //  7381:   case 0x4: {
  OPC_Decode, 229, 11, 63,                   //  7383:    decode to VSRAR_B using decoder 63
                                             //  7383:   }
  5, 4,                                      //  7387:   case 0x5: {
  OPC_Decode, 231, 11, 63,                   //  7389:    decode to VSRAR_H using decoder 63
                                             //  7389:   }
  6, 4,                                      //  7393:   case 0x6: {
  OPC_Decode, 232, 11, 63,                   //  7395:    decode to VSRAR_W using decoder 63
                                             //  7395:   }
  7, 0,                                      //  7399:   case 0x7: {
  OPC_Decode, 230, 11, 63,                   //  7401:    decode to VSRAR_D using decoder 63
                                             //  7401:   }
                                             //  7401:   } // switch Inst[17:15]
                                             //  7401:  }
  61, 39,                                    //  7405:  case 0x3d: {
  OPC_SwitchField, 15, 3,                    //  7407:   switch Inst[17:15] {
  1, 4,                                      //  7410:   case 0x1: {
  OPC_Decode, 245, 11, 63,                   //  7412:    decode to VSRLN_B_H using decoder 63
                                             //  7412:   }
  2, 4,                                      //  7416:   case 0x2: {
  OPC_Decode, 246, 11, 63,                   //  7418:    decode to VSRLN_H_W using decoder 63
                                             //  7418:   }
  3, 4,                                      //  7422:   case 0x3: {
  OPC_Decode, 247, 11, 63,                   //  7424:    decode to VSRLN_W_D using decoder 63
                                             //  7424:   }
  5, 4,                                      //  7428:   case 0x5: {
  OPC_Decode, 215, 11, 63,                   //  7430:    decode to VSRAN_B_H using decoder 63
                                             //  7430:   }
  6, 4,                                      //  7434:   case 0x6: {
  OPC_Decode, 216, 11, 63,                   //  7436:    decode to VSRAN_H_W using decoder 63
                                             //  7436:   }
  7, 0,                                      //  7440:   case 0x7: {
  OPC_Decode, 217, 11, 63,                   //  7442:    decode to VSRAN_W_D using decoder 63
                                             //  7442:   }
                                             //  7442:   } // switch Inst[17:15]
                                             //  7442:  }
  62, 39,                                    //  7446:  case 0x3e: {
  OPC_SwitchField, 15, 3,                    //  7448:   switch Inst[17:15] {
  1, 4,                                      //  7451:   case 0x1: {
  OPC_Decode, 128, 12, 63,                   //  7453:    decode to VSRLRN_B_H using decoder 63
                                             //  7453:   }
  2, 4,                                      //  7457:   case 0x2: {
  OPC_Decode, 129, 12, 63,                   //  7459:    decode to VSRLRN_H_W using decoder 63
                                             //  7459:   }
  3, 4,                                      //  7463:   case 0x3: {
  OPC_Decode, 130, 12, 63,                   //  7465:    decode to VSRLRN_W_D using decoder 63
                                             //  7465:   }
  5, 4,                                      //  7469:   case 0x5: {
  OPC_Decode, 226, 11, 63,                   //  7471:    decode to VSRARN_B_H using decoder 63
                                             //  7471:   }
  6, 4,                                      //  7475:   case 0x6: {
  OPC_Decode, 227, 11, 63,                   //  7477:    decode to VSRARN_H_W using decoder 63
                                             //  7477:   }
  7, 0,                                      //  7481:   case 0x7: {
  OPC_Decode, 228, 11, 63,                   //  7483:    decode to VSRARN_W_D using decoder 63
                                             //  7483:   }
                                             //  7483:   } // switch Inst[17:15]
                                             //  7483:  }
  63, 39,                                    //  7487:  case 0x3f: {
  OPC_SwitchField, 15, 3,                    //  7489:   switch Inst[17:15] {
  1, 4,                                      //  7492:   case 0x1: {
  OPC_Decode, 176, 12, 63,                   //  7494:    decode to VSSRLN_B_H using decoder 63
                                             //  7494:   }
  2, 4,                                      //  7498:   case 0x2: {
  OPC_Decode, 178, 12, 63,                   //  7500:    decode to VSSRLN_H_W using decoder 63
                                             //  7500:   }
  3, 4,                                      //  7504:   case 0x3: {
  OPC_Decode, 180, 12, 63,                   //  7506:    decode to VSSRLN_W_D using decoder 63
                                             //  7506:   }
  5, 4,                                      //  7510:   case 0x5: {
  OPC_Decode, 148, 12, 63,                   //  7512:    decode to VSSRAN_B_H using decoder 63
                                             //  7512:   }
  6, 4,                                      //  7516:   case 0x6: {
  OPC_Decode, 150, 12, 63,                   //  7518:    decode to VSSRAN_H_W using decoder 63
                                             //  7518:   }
  7, 0,                                      //  7522:   case 0x7: {
  OPC_Decode, 152, 12, 63,                   //  7524:    decode to VSSRAN_W_D using decoder 63
                                             //  7524:   }
                                             //  7524:   } // switch Inst[17:15]
                                             //  7524:  }
  64, 39,                                    //  7528:  case 0x40: {
  OPC_SwitchField, 15, 3,                    //  7530:   switch Inst[17:15] {
  1, 4,                                      //  7533:   case 0x1: {
  OPC_Decode, 190, 12, 63,                   //  7535:    decode to VSSRLRN_B_H using decoder 63
                                             //  7535:   }
  2, 4,                                      //  7539:   case 0x2: {
  OPC_Decode, 192, 12, 63,                   //  7541:    decode to VSSRLRN_H_W using decoder 63
                                             //  7541:   }
  3, 4,                                      //  7545:   case 0x3: {
  OPC_Decode, 194, 12, 63,                   //  7547:    decode to VSSRLRN_W_D using decoder 63
                                             //  7547:   }
  5, 4,                                      //  7551:   case 0x5: {
  OPC_Decode, 162, 12, 63,                   //  7553:    decode to VSSRARN_B_H using decoder 63
                                             //  7553:   }
  6, 4,                                      //  7557:   case 0x6: {
  OPC_Decode, 164, 12, 63,                   //  7559:    decode to VSSRARN_H_W using decoder 63
                                             //  7559:   }
  7, 0,                                      //  7563:   case 0x7: {
  OPC_Decode, 166, 12, 63,                   //  7565:    decode to VSSRARN_W_D using decoder 63
                                             //  7565:   }
                                             //  7565:   } // switch Inst[17:15]
                                             //  7565:  }
  65, 39,                                    //  7569:  case 0x41: {
  OPC_SwitchField, 15, 3,                    //  7571:   switch Inst[17:15] {
  1, 4,                                      //  7574:   case 0x1: {
  OPC_Decode, 175, 12, 63,                   //  7576:    decode to VSSRLN_BU_H using decoder 63
                                             //  7576:   }
  2, 4,                                      //  7580:   case 0x2: {
  OPC_Decode, 177, 12, 63,                   //  7582:    decode to VSSRLN_HU_W using decoder 63
                                             //  7582:   }
  3, 4,                                      //  7586:   case 0x3: {
  OPC_Decode, 179, 12, 63,                   //  7588:    decode to VSSRLN_WU_D using decoder 63
                                             //  7588:   }
  5, 4,                                      //  7592:   case 0x5: {
  OPC_Decode, 147, 12, 63,                   //  7594:    decode to VSSRAN_BU_H using decoder 63
                                             //  7594:   }
  6, 4,                                      //  7598:   case 0x6: {
  OPC_Decode, 149, 12, 63,                   //  7600:    decode to VSSRAN_HU_W using decoder 63
                                             //  7600:   }
  7, 0,                                      //  7604:   case 0x7: {
  OPC_Decode, 151, 12, 63,                   //  7606:    decode to VSSRAN_WU_D using decoder 63
                                             //  7606:   }
                                             //  7606:   } // switch Inst[17:15]
                                             //  7606:  }
  66, 39,                                    //  7610:  case 0x42: {
  OPC_SwitchField, 15, 3,                    //  7612:   switch Inst[17:15] {
  1, 4,                                      //  7615:   case 0x1: {
  OPC_Decode, 189, 12, 63,                   //  7617:    decode to VSSRLRN_BU_H using decoder 63
                                             //  7617:   }
  2, 4,                                      //  7621:   case 0x2: {
  OPC_Decode, 191, 12, 63,                   //  7623:    decode to VSSRLRN_HU_W using decoder 63
                                             //  7623:   }
  3, 4,                                      //  7627:   case 0x3: {
  OPC_Decode, 193, 12, 63,                   //  7629:    decode to VSSRLRN_WU_D using decoder 63
                                             //  7629:   }
  5, 4,                                      //  7633:   case 0x5: {
  OPC_Decode, 161, 12, 63,                   //  7635:    decode to VSSRARN_BU_H using decoder 63
                                             //  7635:   }
  6, 4,                                      //  7639:   case 0x6: {
  OPC_Decode, 163, 12, 63,                   //  7641:    decode to VSSRARN_HU_W using decoder 63
                                             //  7641:   }
  7, 0,                                      //  7645:   case 0x7: {
  OPC_Decode, 165, 12, 63,                   //  7647:    decode to VSSRARN_WU_D using decoder 63
                                             //  7647:   }
                                             //  7647:   } // switch Inst[17:15]
                                             //  7647:  }
  67, 51,                                    //  7651:  case 0x43: {
  OPC_SwitchField, 15, 3,                    //  7653:   switch Inst[17:15] {
  0, 4,                                      //  7656:   case 0x0: {
  OPC_Decode, 216, 7, 63,                    //  7658:    decode to VBITCLR_B using decoder 63
                                             //  7658:   }
  1, 4,                                      //  7662:   case 0x1: {
  OPC_Decode, 218, 7, 63,                    //  7664:    decode to VBITCLR_H using decoder 63
                                             //  7664:   }
  2, 4,                                      //  7668:   case 0x2: {
  OPC_Decode, 219, 7, 63,                    //  7670:    decode to VBITCLR_W using decoder 63
                                             //  7670:   }
  3, 4,                                      //  7674:   case 0x3: {
  OPC_Decode, 217, 7, 63,                    //  7676:    decode to VBITCLR_D using decoder 63
                                             //  7676:   }
  4, 4,                                      //  7680:   case 0x4: {
  OPC_Decode, 234, 7, 63,                    //  7682:    decode to VBITSET_B using decoder 63
                                             //  7682:   }
  5, 4,                                      //  7686:   case 0x5: {
  OPC_Decode, 236, 7, 63,                    //  7688:    decode to VBITSET_H using decoder 63
                                             //  7688:   }
  6, 4,                                      //  7692:   case 0x6: {
  OPC_Decode, 237, 7, 63,                    //  7694:    decode to VBITSET_W using decoder 63
                                             //  7694:   }
  7, 0,                                      //  7698:   case 0x7: {
  OPC_Decode, 235, 7, 63,                    //  7700:    decode to VBITSET_D using decoder 63
                                             //  7700:   }
                                             //  7700:   } // switch Inst[17:15]
                                             //  7700:  }
  68, 27,                                    //  7704:  case 0x44: {
  OPC_SwitchField, 15, 3,                    //  7706:   switch Inst[17:15] {
  0, 4,                                      //  7709:   case 0x0: {
  OPC_Decode, 224, 7, 63,                    //  7711:    decode to VBITREV_B using decoder 63
                                             //  7711:   }
  1, 4,                                      //  7715:   case 0x1: {
  OPC_Decode, 226, 7, 63,                    //  7717:    decode to VBITREV_H using decoder 63
                                             //  7717:   }
  2, 4,                                      //  7721:   case 0x2: {
  OPC_Decode, 227, 7, 63,                    //  7723:    decode to VBITREV_W using decoder 63
                                             //  7723:   }
  3, 0,                                      //  7727:   case 0x3: {
  OPC_Decode, 225, 7, 63,                    //  7729:    decode to VBITREV_D using decoder 63
                                             //  7729:   }
                                             //  7729:   } // switch Inst[17:15]
                                             //  7729:  }
  69, 27,                                    //  7733:  case 0x45: {
  OPC_SwitchField, 15, 3,                    //  7735:   switch Inst[17:15] {
  4, 4,                                      //  7738:   case 0x4: {
  OPC_Decode, 194, 10, 63,                   //  7740:    decode to VPACKEV_B using decoder 63
                                             //  7740:   }
  5, 4,                                      //  7744:   case 0x5: {
  OPC_Decode, 196, 10, 63,                   //  7746:    decode to VPACKEV_H using decoder 63
                                             //  7746:   }
  6, 4,                                      //  7750:   case 0x6: {
  OPC_Decode, 197, 10, 63,                   //  7752:    decode to VPACKEV_W using decoder 63
                                             //  7752:   }
  7, 0,                                      //  7756:   case 0x7: {
  OPC_Decode, 195, 10, 63,                   //  7758:    decode to VPACKEV_D using decoder 63
                                             //  7758:   }
                                             //  7758:   } // switch Inst[17:15]
                                             //  7758:  }
  70, 51,                                    //  7762:  case 0x46: {
  OPC_SwitchField, 15, 3,                    //  7764:   switch Inst[17:15] {
  0, 4,                                      //  7767:   case 0x0: {
  OPC_Decode, 198, 10, 63,                   //  7769:    decode to VPACKOD_B using decoder 63
                                             //  7769:   }
  1, 4,                                      //  7773:   case 0x1: {
  OPC_Decode, 200, 10, 63,                   //  7775:    decode to VPACKOD_H using decoder 63
                                             //  7775:   }
  2, 4,                                      //  7779:   case 0x2: {
  OPC_Decode, 201, 10, 63,                   //  7781:    decode to VPACKOD_W using decoder 63
                                             //  7781:   }
  3, 4,                                      //  7785:   case 0x3: {
  OPC_Decode, 199, 10, 63,                   //  7787:    decode to VPACKOD_D using decoder 63
                                             //  7787:   }
  4, 4,                                      //  7791:   case 0x4: {
  OPC_Decode, 184, 9, 63,                    //  7793:    decode to VILVL_B using decoder 63
                                             //  7793:   }
  5, 4,                                      //  7797:   case 0x5: {
  OPC_Decode, 186, 9, 63,                    //  7799:    decode to VILVL_H using decoder 63
                                             //  7799:   }
  6, 4,                                      //  7803:   case 0x6: {
  OPC_Decode, 187, 9, 63,                    //  7805:    decode to VILVL_W using decoder 63
                                             //  7805:   }
  7, 0,                                      //  7809:   case 0x7: {
  OPC_Decode, 185, 9, 63,                    //  7811:    decode to VILVL_D using decoder 63
                                             //  7811:   }
                                             //  7811:   } // switch Inst[17:15]
                                             //  7811:  }
  71, 51,                                    //  7815:  case 0x47: {
  OPC_SwitchField, 15, 3,                    //  7817:   switch Inst[17:15] {
  0, 4,                                      //  7820:   case 0x0: {
  OPC_Decode, 180, 9, 63,                    //  7822:    decode to VILVH_B using decoder 63
                                             //  7822:   }
  1, 4,                                      //  7826:   case 0x1: {
  OPC_Decode, 182, 9, 63,                    //  7828:    decode to VILVH_H using decoder 63
                                             //  7828:   }
  2, 4,                                      //  7832:   case 0x2: {
  OPC_Decode, 183, 9, 63,                    //  7834:    decode to VILVH_W using decoder 63
                                             //  7834:   }
  3, 4,                                      //  7838:   case 0x3: {
  OPC_Decode, 181, 9, 63,                    //  7840:    decode to VILVH_D using decoder 63
                                             //  7840:   }
  4, 4,                                      //  7844:   case 0x4: {
  OPC_Decode, 207, 10, 63,                   //  7846:    decode to VPICKEV_B using decoder 63
                                             //  7846:   }
  5, 4,                                      //  7850:   case 0x5: {
  OPC_Decode, 209, 10, 63,                   //  7852:    decode to VPICKEV_H using decoder 63
                                             //  7852:   }
  6, 4,                                      //  7856:   case 0x6: {
  OPC_Decode, 210, 10, 63,                   //  7858:    decode to VPICKEV_W using decoder 63
                                             //  7858:   }
  7, 0,                                      //  7862:   case 0x7: {
  OPC_Decode, 208, 10, 63,                   //  7864:    decode to VPICKEV_D using decoder 63
                                             //  7864:   }
                                             //  7864:   } // switch Inst[17:15]
                                             //  7864:  }
  72, 51,                                    //  7868:  case 0x48: {
  OPC_SwitchField, 15, 3,                    //  7870:   switch Inst[17:15] {
  0, 4,                                      //  7873:   case 0x0: {
  OPC_Decode, 211, 10, 63,                   //  7875:    decode to VPICKOD_B using decoder 63
                                             //  7875:   }
  1, 4,                                      //  7879:   case 0x1: {
  OPC_Decode, 213, 10, 63,                   //  7881:    decode to VPICKOD_H using decoder 63
                                             //  7881:   }
  2, 4,                                      //  7885:   case 0x2: {
  OPC_Decode, 214, 10, 63,                   //  7887:    decode to VPICKOD_W using decoder 63
                                             //  7887:   }
  3, 4,                                      //  7891:   case 0x3: {
  OPC_Decode, 212, 10, 63,                   //  7893:    decode to VPICKOD_D using decoder 63
                                             //  7893:   }
  4, 4,                                      //  7897:   case 0x4: {
  OPC_Decode, 231, 10, 105,                  //  7899:    decode to VREPLVE_B using decoder 105
                                             //  7899:   }
  5, 4,                                      //  7903:   case 0x5: {
  OPC_Decode, 233, 10, 105,                  //  7905:    decode to VREPLVE_H using decoder 105
                                             //  7905:   }
  6, 4,                                      //  7909:   case 0x6: {
  OPC_Decode, 234, 10, 105,                  //  7911:    decode to VREPLVE_W using decoder 105
                                             //  7911:   }
  7, 0,                                      //  7915:   case 0x7: {
  OPC_Decode, 232, 10, 105,                  //  7917:    decode to VREPLVE_D using decoder 105
                                             //  7917:   }
                                             //  7917:   } // switch Inst[17:15]
                                             //  7917:  }
  73, 27,                                    //  7921:  case 0x49: {
  OPC_SwitchField, 15, 3,                    //  7923:   switch Inst[17:15] {
  4, 4,                                      //  7926:   case 0x4: {
  OPC_Decode, 195, 7, 63,                    //  7928:    decode to VAND_V using decoder 63
                                             //  7928:   }
  5, 4,                                      //  7932:   case 0x5: {
  OPC_Decode, 193, 10, 63,                   //  7934:    decode to VOR_V using decoder 63
                                             //  7934:   }
  6, 4,                                      //  7938:   case 0x6: {
  OPC_Decode, 235, 12, 63,                   //  7940:    decode to VXOR_V using decoder 63
                                             //  7940:   }
  7, 0,                                      //  7944:   case 0x7: {
  OPC_Decode, 190, 10, 63,                   //  7946:    decode to VNOR_V using decoder 63
                                             //  7946:   }
                                             //  7946:   } // switch Inst[17:15]
                                             //  7946:  }
  74, 27,                                    //  7950:  case 0x4a: {
  OPC_SwitchField, 15, 3,                    //  7952:   switch Inst[17:15] {
  0, 4,                                      //  7955:   case 0x0: {
  OPC_Decode, 194, 7, 63,                    //  7957:    decode to VANDN_V using decoder 63
                                             //  7957:   }
  1, 4,                                      //  7961:   case 0x1: {
  OPC_Decode, 192, 10, 63,                   //  7963:    decode to VORN_V using decoder 63
                                             //  7963:   }
  6, 4,                                      //  7967:   case 0x6: {
  OPC_Decode, 129, 9, 104,                   //  7969:    decode to VFRSTP_B using decoder 104
                                             //  7969:   }
  7, 0,                                      //  7973:   case 0x7: {
  OPC_Decode, 130, 9, 104,                   //  7975:    decode to VFRSTP_H using decoder 104
                                             //  7975:   }
                                             //  7975:   } // switch Inst[17:15]
                                             //  7975:  }
  75, 39,                                    //  7979:  case 0x4b: {
  OPC_SwitchField, 15, 3,                    //  7981:   switch Inst[17:15] {
  2, 4,                                      //  7984:   case 0x2: {
  OPC_Decode, 191, 7, 63,                    //  7986:    decode to VADD_Q using decoder 63
                                             //  7986:   }
  3, 4,                                      //  7990:   case 0x3: {
  OPC_Decode, 232, 12, 63,                   //  7992:    decode to VSUB_Q using decoder 63
                                             //  7992:   }
  4, 4,                                      //  7996:   case 0x4: {
  OPC_Decode, 157, 11, 63,                   //  7998:    decode to VSIGNCOV_B using decoder 63
                                             //  7998:   }
  5, 4,                                      //  8002:   case 0x5: {
  OPC_Decode, 159, 11, 63,                   //  8004:    decode to VSIGNCOV_H using decoder 63
                                             //  8004:   }
  6, 4,                                      //  8008:   case 0x6: {
  OPC_Decode, 160, 11, 63,                   //  8010:    decode to VSIGNCOV_W using decoder 63
                                             //  8010:   }
  7, 0,                                      //  8014:   case 0x7: {
  OPC_Decode, 158, 11, 63,                   //  8016:    decode to VSIGNCOV_D using decoder 63
                                             //  8016:   }
                                             //  8016:   } // switch Inst[17:15]
                                             //  8016:  }
  76, 27,                                    //  8020:  case 0x4c: {
  OPC_SwitchField, 15, 3,                    //  8022:   switch Inst[17:15] {
  1, 4,                                      //  8025:   case 0x1: {
  OPC_Decode, 155, 8, 63,                    //  8027:    decode to VFADD_S using decoder 63
                                             //  8027:   }
  2, 4,                                      //  8031:   case 0x2: {
  OPC_Decode, 154, 8, 63,                    //  8033:    decode to VFADD_D using decoder 63
                                             //  8033:   }
  5, 4,                                      //  8037:   case 0x5: {
  OPC_Decode, 134, 9, 63,                    //  8039:    decode to VFSUB_S using decoder 63
                                             //  8039:   }
  6, 0,                                      //  8043:   case 0x6: {
  OPC_Decode, 133, 9, 63,                    //  8045:    decode to VFSUB_D using decoder 63
                                             //  8045:   }
                                             //  8045:   } // switch Inst[17:15]
                                             //  8045:  }
  78, 27,                                    //  8049:  case 0x4e: {
  OPC_SwitchField, 15, 3,                    //  8051:   switch Inst[17:15] {
  1, 4,                                      //  8054:   case 0x1: {
  OPC_Decode, 232, 8, 63,                    //  8056:    decode to VFMUL_S using decoder 63
                                             //  8056:   }
  2, 4,                                      //  8060:   case 0x2: {
  OPC_Decode, 231, 8, 63,                    //  8062:    decode to VFMUL_D using decoder 63
                                             //  8062:   }
  5, 4,                                      //  8066:   case 0x5: {
  OPC_Decode, 209, 8, 63,                    //  8068:    decode to VFDIV_S using decoder 63
                                             //  8068:   }
  6, 0,                                      //  8072:   case 0x6: {
  OPC_Decode, 208, 8, 63,                    //  8074:    decode to VFDIV_D using decoder 63
                                             //  8074:   }
                                             //  8074:   } // switch Inst[17:15]
                                             //  8074:  }
  79, 27,                                    //  8078:  case 0x4f: {
  OPC_SwitchField, 15, 3,                    //  8080:   switch Inst[17:15] {
  1, 4,                                      //  8083:   case 0x1: {
  OPC_Decode, 224, 8, 63,                    //  8085:    decode to VFMAX_S using decoder 63
                                             //  8085:   }
  2, 4,                                      //  8089:   case 0x2: {
  OPC_Decode, 223, 8, 63,                    //  8091:    decode to VFMAX_D using decoder 63
                                             //  8091:   }
  5, 4,                                      //  8095:   case 0x5: {
  OPC_Decode, 228, 8, 63,                    //  8097:    decode to VFMIN_S using decoder 63
                                             //  8097:   }
  6, 0,                                      //  8101:   case 0x6: {
  OPC_Decode, 227, 8, 63,                    //  8103:    decode to VFMIN_D using decoder 63
                                             //  8103:   }
                                             //  8103:   } // switch Inst[17:15]
                                             //  8103:  }
  80, 27,                                    //  8107:  case 0x50: {
  OPC_SwitchField, 15, 3,                    //  8109:   switch Inst[17:15] {
  1, 4,                                      //  8112:   case 0x1: {
  OPC_Decode, 222, 8, 63,                    //  8114:    decode to VFMAXA_S using decoder 63
                                             //  8114:   }
  2, 4,                                      //  8118:   case 0x2: {
  OPC_Decode, 221, 8, 63,                    //  8120:    decode to VFMAXA_D using decoder 63
                                             //  8120:   }
  5, 4,                                      //  8124:   case 0x5: {
  OPC_Decode, 226, 8, 63,                    //  8126:    decode to VFMINA_S using decoder 63
                                             //  8126:   }
  6, 0,                                      //  8130:   case 0x6: {
  OPC_Decode, 225, 8, 63,                    //  8132:    decode to VFMINA_D using decoder 63
                                             //  8132:   }
                                             //  8132:   } // switch Inst[17:15]
                                             //  8132:  }
  81, 15,                                    //  8136:  case 0x51: {
  OPC_SwitchField, 15, 3,                    //  8138:   switch Inst[17:15] {
  4, 4,                                      //  8141:   case 0x4: {
  OPC_Decode, 206, 8, 63,                    //  8143:    decode to VFCVT_H_S using decoder 63
                                             //  8143:   }
  5, 0,                                      //  8147:   case 0x5: {
  OPC_Decode, 207, 8, 63,                    //  8149:    decode to VFCVT_S_D using decoder 63
                                             //  8149:   }
                                             //  8149:   } // switch Inst[17:15]
                                             //  8149:  }
  82, 39,                                    //  8153:  case 0x52: {
  OPC_SwitchField, 15, 3,                    //  8155:   switch Inst[17:15] {
  0, 4,                                      //  8158:   case 0x0: {
  OPC_Decode, 214, 8, 63,                    //  8160:    decode to VFFINT_S_L using decoder 63
                                             //  8160:   }
  3, 4,                                      //  8164:   case 0x3: {
  OPC_Decode, 162, 9, 63,                    //  8166:    decode to VFTINT_W_D using decoder 63
                                             //  8166:   }
  4, 4,                                      //  8170:   case 0x4: {
  OPC_Decode, 140, 9, 63,                    //  8172:    decode to VFTINTRM_W_D using decoder 63
                                             //  8172:   }
  5, 4,                                      //  8176:   case 0x5: {
  OPC_Decode, 150, 9, 63,                    //  8178:    decode to VFTINTRP_W_D using decoder 63
                                             //  8178:   }
  6, 4,                                      //  8182:   case 0x6: {
  OPC_Decode, 157, 9, 63,                    //  8184:    decode to VFTINTRZ_W_D using decoder 63
                                             //  8184:   }
  7, 0,                                      //  8188:   case 0x7: {
  OPC_Decode, 145, 9, 63,                    //  8190:    decode to VFTINTRNE_W_D using decoder 63
                                             //  8190:   }
                                             //  8190:   } // switch Inst[17:15]
                                             //  8190:  }
  94, 21,                                    //  8194:  case 0x5e: {
  OPC_SwitchField, 15, 3,                    //  8196:   switch Inst[17:15] {
  5, 4,                                      //  8199:   case 0x5: {
  OPC_Decode, 155, 11, 104,                  //  8201:    decode to VSHUF_H using decoder 104
                                             //  8201:   }
  6, 4,                                      //  8205:   case 0x6: {
  OPC_Decode, 156, 11, 104,                  //  8207:    decode to VSHUF_W using decoder 104
                                             //  8207:   }
  7, 0,                                      //  8211:   case 0x7: {
  OPC_Decode, 154, 11, 104,                  //  8213:    decode to VSHUF_D using decoder 104
                                             //  8213:   }
                                             //  8213:   } // switch Inst[17:15]
                                             //  8213:  }
  160, 1, 51,                                //  8217:  case 0xa0: {
  OPC_SwitchField, 15, 3,                    //  8220:   switch Inst[17:15] {
  0, 4,                                      //  8223:   case 0x0: {
  OPC_Decode, 131, 11, 106,                  //  8225:    decode to VSEQI_B using decoder 106
                                             //  8225:   }
  1, 4,                                      //  8229:   case 0x1: {
  OPC_Decode, 133, 11, 106,                  //  8231:    decode to VSEQI_H using decoder 106
                                             //  8231:   }
  2, 4,                                      //  8235:   case 0x2: {
  OPC_Decode, 134, 11, 106,                  //  8237:    decode to VSEQI_W using decoder 106
                                             //  8237:   }
  3, 4,                                      //  8241:   case 0x3: {
  OPC_Decode, 132, 11, 106,                  //  8243:    decode to VSEQI_D using decoder 106
                                             //  8243:   }
  4, 4,                                      //  8247:   case 0x4: {
  OPC_Decode, 161, 11, 106,                  //  8249:    decode to VSLEI_B using decoder 106
                                             //  8249:   }
  5, 4,                                      //  8253:   case 0x5: {
  OPC_Decode, 165, 11, 106,                  //  8255:    decode to VSLEI_H using decoder 106
                                             //  8255:   }
  6, 4,                                      //  8259:   case 0x6: {
  OPC_Decode, 167, 11, 106,                  //  8261:    decode to VSLEI_W using decoder 106
                                             //  8261:   }
  7, 0,                                      //  8265:   case 0x7: {
  OPC_Decode, 163, 11, 106,                  //  8267:    decode to VSLEI_D using decoder 106
                                             //  8267:   }
                                             //  8267:   } // switch Inst[17:15]
                                             //  8267:  }
  161, 1, 51,                                //  8271:  case 0xa1: {
  OPC_SwitchField, 15, 3,                    //  8274:   switch Inst[17:15] {
  0, 4,                                      //  8277:   case 0x0: {
  OPC_Decode, 162, 11, 107,                  //  8279:    decode to VSLEI_BU using decoder 107
                                             //  8279:   }
  1, 4,                                      //  8283:   case 0x1: {
  OPC_Decode, 166, 11, 107,                  //  8285:    decode to VSLEI_HU using decoder 107
                                             //  8285:   }
  2, 4,                                      //  8289:   case 0x2: {
  OPC_Decode, 168, 11, 107,                  //  8291:    decode to VSLEI_WU using decoder 107
                                             //  8291:   }
  3, 4,                                      //  8295:   case 0x3: {
  OPC_Decode, 164, 11, 107,                  //  8297:    decode to VSLEI_DU using decoder 107
                                             //  8297:   }
  4, 4,                                      //  8301:   case 0x4: {
  OPC_Decode, 191, 11, 106,                  //  8303:    decode to VSLTI_B using decoder 106
                                             //  8303:   }
  5, 4,                                      //  8307:   case 0x5: {
  OPC_Decode, 195, 11, 106,                  //  8309:    decode to VSLTI_H using decoder 106
                                             //  8309:   }
  6, 4,                                      //  8313:   case 0x6: {
  OPC_Decode, 197, 11, 106,                  //  8315:    decode to VSLTI_W using decoder 106
                                             //  8315:   }
  7, 0,                                      //  8319:   case 0x7: {
  OPC_Decode, 193, 11, 106,                  //  8321:    decode to VSLTI_D using decoder 106
                                             //  8321:   }
                                             //  8321:   } // switch Inst[17:15]
                                             //  8321:  }
  162, 1, 51,                                //  8325:  case 0xa2: {
  OPC_SwitchField, 15, 3,                    //  8328:   switch Inst[17:15] {
  0, 4,                                      //  8331:   case 0x0: {
  OPC_Decode, 192, 11, 107,                  //  8333:    decode to VSLTI_BU using decoder 107
                                             //  8333:   }
  1, 4,                                      //  8337:   case 0x1: {
  OPC_Decode, 196, 11, 107,                  //  8339:    decode to VSLTI_HU using decoder 107
                                             //  8339:   }
  2, 4,                                      //  8343:   case 0x2: {
  OPC_Decode, 198, 11, 107,                  //  8345:    decode to VSLTI_WU using decoder 107
                                             //  8345:   }
  3, 4,                                      //  8349:   case 0x3: {
  OPC_Decode, 194, 11, 107,                  //  8351:    decode to VSLTI_DU using decoder 107
                                             //  8351:   }
  4, 4,                                      //  8355:   case 0x4: {
  OPC_Decode, 160, 7, 107,                   //  8357:    decode to VADDI_BU using decoder 107
                                             //  8357:   }
  5, 4,                                      //  8361:   case 0x5: {
  OPC_Decode, 162, 7, 107,                   //  8363:    decode to VADDI_HU using decoder 107
                                             //  8363:   }
  6, 4,                                      //  8367:   case 0x6: {
  OPC_Decode, 163, 7, 107,                   //  8369:    decode to VADDI_WU using decoder 107
                                             //  8369:   }
  7, 0,                                      //  8373:   case 0x7: {
  OPC_Decode, 161, 7, 107,                   //  8375:    decode to VADDI_DU using decoder 107
                                             //  8375:   }
                                             //  8375:   } // switch Inst[17:15]
                                             //  8375:  }
  163, 1, 39,                                //  8379:  case 0xa3: {
  OPC_SwitchField, 15, 3,                    //  8382:   switch Inst[17:15] {
  0, 4,                                      //  8385:   case 0x0: {
  OPC_Decode, 209, 12, 107,                  //  8387:    decode to VSUBI_BU using decoder 107
                                             //  8387:   }
  1, 4,                                      //  8391:   case 0x1: {
  OPC_Decode, 211, 12, 107,                  //  8393:    decode to VSUBI_HU using decoder 107
                                             //  8393:   }
  2, 4,                                      //  8397:   case 0x2: {
  OPC_Decode, 212, 12, 107,                  //  8399:    decode to VSUBI_WU using decoder 107
                                             //  8399:   }
  3, 4,                                      //  8403:   case 0x3: {
  OPC_Decode, 210, 12, 107,                  //  8405:    decode to VSUBI_DU using decoder 107
                                             //  8405:   }
  4, 4,                                      //  8409:   case 0x4: {
  OPC_Decode, 238, 7, 107,                   //  8411:    decode to VBSLL_V using decoder 107
                                             //  8411:   }
  5, 0,                                      //  8415:   case 0x5: {
  OPC_Decode, 239, 7, 107,                   //  8417:    decode to VBSRL_V using decoder 107
                                             //  8417:   }
                                             //  8417:   } // switch Inst[17:15]
                                             //  8417:  }
  164, 1, 51,                                //  8421:  case 0xa4: {
  OPC_SwitchField, 15, 3,                    //  8424:   switch Inst[17:15] {
  0, 4,                                      //  8427:   case 0x0: {
  OPC_Decode, 227, 9, 106,                   //  8429:    decode to VMAXI_B using decoder 106
                                             //  8429:   }
  1, 4,                                      //  8433:   case 0x1: {
  OPC_Decode, 231, 9, 106,                   //  8435:    decode to VMAXI_H using decoder 106
                                             //  8435:   }
  2, 4,                                      //  8439:   case 0x2: {
  OPC_Decode, 233, 9, 106,                   //  8441:    decode to VMAXI_W using decoder 106
                                             //  8441:   }
  3, 4,                                      //  8445:   case 0x3: {
  OPC_Decode, 229, 9, 106,                   //  8447:    decode to VMAXI_D using decoder 106
                                             //  8447:   }
  4, 4,                                      //  8451:   case 0x4: {
  OPC_Decode, 243, 9, 106,                   //  8453:    decode to VMINI_B using decoder 106
                                             //  8453:   }
  5, 4,                                      //  8457:   case 0x5: {
  OPC_Decode, 247, 9, 106,                   //  8459:    decode to VMINI_H using decoder 106
                                             //  8459:   }
  6, 4,                                      //  8463:   case 0x6: {
  OPC_Decode, 249, 9, 106,                   //  8465:    decode to VMINI_W using decoder 106
                                             //  8465:   }
  7, 0,                                      //  8469:   case 0x7: {
  OPC_Decode, 245, 9, 106,                   //  8471:    decode to VMINI_D using decoder 106
                                             //  8471:   }
                                             //  8471:   } // switch Inst[17:15]
                                             //  8471:  }
  165, 1, 51,                                //  8475:  case 0xa5: {
  OPC_SwitchField, 15, 3,                    //  8478:   switch Inst[17:15] {
  0, 4,                                      //  8481:   case 0x0: {
  OPC_Decode, 228, 9, 107,                   //  8483:    decode to VMAXI_BU using decoder 107
                                             //  8483:   }
  1, 4,                                      //  8487:   case 0x1: {
  OPC_Decode, 232, 9, 107,                   //  8489:    decode to VMAXI_HU using decoder 107
                                             //  8489:   }
  2, 4,                                      //  8493:   case 0x2: {
  OPC_Decode, 234, 9, 107,                   //  8495:    decode to VMAXI_WU using decoder 107
                                             //  8495:   }
  3, 4,                                      //  8499:   case 0x3: {
  OPC_Decode, 230, 9, 107,                   //  8501:    decode to VMAXI_DU using decoder 107
                                             //  8501:   }
  4, 4,                                      //  8505:   case 0x4: {
  OPC_Decode, 244, 9, 107,                   //  8507:    decode to VMINI_BU using decoder 107
                                             //  8507:   }
  5, 4,                                      //  8511:   case 0x5: {
  OPC_Decode, 248, 9, 107,                   //  8513:    decode to VMINI_HU using decoder 107
                                             //  8513:   }
  6, 4,                                      //  8517:   case 0x6: {
  OPC_Decode, 250, 9, 107,                   //  8519:    decode to VMINI_WU using decoder 107
                                             //  8519:   }
  7, 0,                                      //  8523:   case 0x7: {
  OPC_Decode, 246, 9, 107,                   //  8525:    decode to VMINI_DU using decoder 107
                                             //  8525:   }
                                             //  8525:   } // switch Inst[17:15]
                                             //  8525:  }
  166, 1, 15,                                //  8529:  case 0xa6: {
  OPC_SwitchField, 15, 3,                    //  8532:   switch Inst[17:15] {
  4, 4,                                      //  8535:   case 0x4: {
  OPC_Decode, 255, 8, 108,                   //  8537:    decode to VFRSTPI_B using decoder 108
                                             //  8537:   }
  5, 0,                                      //  8541:   case 0x5: {
  OPC_Decode, 128, 9, 108,                   //  8543:    decode to VFRSTPI_H using decoder 108
                                             //  8543:   }
                                             //  8543:   } // switch Inst[17:15]
                                             //  8543:  }
  167, 1, 185, 5,                            //  8547:  case 0xa7: {
  OPC_SwitchField, 10, 8,                    //  8551:   switch Inst[17:10] {
  0, 4,                                      //  8554:   case 0x0: {
  OPC_Decode, 240, 7, 109,                   //  8556:    decode to VCLO_B using decoder 109
                                             //  8556:   }
  1, 4,                                      //  8560:   case 0x1: {
  OPC_Decode, 242, 7, 109,                   //  8562:    decode to VCLO_H using decoder 109
                                             //  8562:   }
  2, 4,                                      //  8566:   case 0x2: {
  OPC_Decode, 243, 7, 109,                   //  8568:    decode to VCLO_W using decoder 109
                                             //  8568:   }
  3, 4,                                      //  8572:   case 0x3: {
  OPC_Decode, 241, 7, 109,                   //  8574:    decode to VCLO_D using decoder 109
                                             //  8574:   }
  4, 4,                                      //  8578:   case 0x4: {
  OPC_Decode, 244, 7, 109,                   //  8580:    decode to VCLZ_B using decoder 109
                                             //  8580:   }
  5, 4,                                      //  8584:   case 0x5: {
  OPC_Decode, 246, 7, 109,                   //  8586:    decode to VCLZ_H using decoder 109
                                             //  8586:   }
  6, 4,                                      //  8590:   case 0x6: {
  OPC_Decode, 247, 7, 109,                   //  8592:    decode to VCLZ_W using decoder 109
                                             //  8592:   }
  7, 4,                                      //  8596:   case 0x7: {
  OPC_Decode, 245, 7, 109,                   //  8598:    decode to VCLZ_D using decoder 109
                                             //  8598:   }
  8, 4,                                      //  8602:   case 0x8: {
  OPC_Decode, 202, 10, 109,                  //  8604:    decode to VPCNT_B using decoder 109
                                             //  8604:   }
  9, 4,                                      //  8608:   case 0x9: {
  OPC_Decode, 204, 10, 109,                  //  8610:    decode to VPCNT_H using decoder 109
                                             //  8610:   }
  10, 4,                                     //  8614:   case 0xa: {
  OPC_Decode, 205, 10, 109,                  //  8616:    decode to VPCNT_W using decoder 109
                                             //  8616:   }
  11, 4,                                     //  8620:   case 0xb: {
  OPC_Decode, 203, 10, 109,                  //  8622:    decode to VPCNT_D using decoder 109
                                             //  8622:   }
  12, 4,                                     //  8626:   case 0xc: {
  OPC_Decode, 185, 10, 109,                  //  8628:    decode to VNEG_B using decoder 109
                                             //  8628:   }
  13, 4,                                     //  8632:   case 0xd: {
  OPC_Decode, 187, 10, 109,                  //  8634:    decode to VNEG_H using decoder 109
                                             //  8634:   }
  14, 4,                                     //  8638:   case 0xe: {
  OPC_Decode, 188, 10, 109,                  //  8640:    decode to VNEG_W using decoder 109
                                             //  8640:   }
  15, 4,                                     //  8644:   case 0xf: {
  OPC_Decode, 186, 10, 109,                  //  8646:    decode to VNEG_D using decoder 109
                                             //  8646:   }
  16, 4,                                     //  8650:   case 0x10: {
  OPC_Decode, 140, 10, 109,                  //  8652:    decode to VMSKLTZ_B using decoder 109
                                             //  8652:   }
  17, 4,                                     //  8656:   case 0x11: {
  OPC_Decode, 142, 10, 109,                  //  8658:    decode to VMSKLTZ_H using decoder 109
                                             //  8658:   }
  18, 4,                                     //  8662:   case 0x12: {
  OPC_Decode, 143, 10, 109,                  //  8664:    decode to VMSKLTZ_W using decoder 109
                                             //  8664:   }
  19, 4,                                     //  8668:   case 0x13: {
  OPC_Decode, 141, 10, 109,                  //  8670:    decode to VMSKLTZ_D using decoder 109
                                             //  8670:   }
  20, 4,                                     //  8674:   case 0x14: {
  OPC_Decode, 139, 10, 109,                  //  8676:    decode to VMSKGEZ_B using decoder 109
                                             //  8676:   }
  24, 4,                                     //  8680:   case 0x18: {
  OPC_Decode, 144, 10, 109,                  //  8682:    decode to VMSKNZ_B using decoder 109
                                             //  8682:   }
  38, 8,                                     //  8686:   case 0x26: {
  OPC_CheckField, 3, 2, 0,                   //  8688:    check Inst[4:3] == 0x0
  OPC_Decode, 147, 11, 110,                  //  8692:    decode to VSETEQZ_V using decoder 110
                                             //  8692:   }
  39, 8,                                     //  8696:   case 0x27: {
  OPC_CheckField, 3, 2, 0,                   //  8698:    check Inst[4:3] == 0x0
  OPC_Decode, 148, 11, 110,                  //  8702:    decode to VSETNEZ_V using decoder 110
                                             //  8702:   }
  40, 8,                                     //  8706:   case 0x28: {
  OPC_CheckField, 3, 2, 0,                   //  8708:    check Inst[4:3] == 0x0
  OPC_Decode, 143, 11, 110,                  //  8712:    decode to VSETANYEQZ_B using decoder 110
                                             //  8712:   }
  41, 8,                                     //  8716:   case 0x29: {
  OPC_CheckField, 3, 2, 0,                   //  8718:    check Inst[4:3] == 0x0
  OPC_Decode, 145, 11, 110,                  //  8722:    decode to VSETANYEQZ_H using decoder 110
                                             //  8722:   }
  42, 8,                                     //  8726:   case 0x2a: {
  OPC_CheckField, 3, 2, 0,                   //  8728:    check Inst[4:3] == 0x0
  OPC_Decode, 146, 11, 110,                  //  8732:    decode to VSETANYEQZ_W using decoder 110
                                             //  8732:   }
  43, 8,                                     //  8736:   case 0x2b: {
  OPC_CheckField, 3, 2, 0,                   //  8738:    check Inst[4:3] == 0x0
  OPC_Decode, 144, 11, 110,                  //  8742:    decode to VSETANYEQZ_D using decoder 110
                                             //  8742:   }
  44, 8,                                     //  8746:   case 0x2c: {
  OPC_CheckField, 3, 2, 0,                   //  8748:    check Inst[4:3] == 0x0
  OPC_Decode, 139, 11, 110,                  //  8752:    decode to VSETALLNEZ_B using decoder 110
                                             //  8752:   }
  45, 8,                                     //  8756:   case 0x2d: {
  OPC_CheckField, 3, 2, 0,                   //  8758:    check Inst[4:3] == 0x0
  OPC_Decode, 141, 11, 110,                  //  8762:    decode to VSETALLNEZ_H using decoder 110
                                             //  8762:   }
  46, 8,                                     //  8766:   case 0x2e: {
  OPC_CheckField, 3, 2, 0,                   //  8768:    check Inst[4:3] == 0x0
  OPC_Decode, 142, 11, 110,                  //  8772:    decode to VSETALLNEZ_W using decoder 110
                                             //  8772:   }
  47, 8,                                     //  8776:   case 0x2f: {
  OPC_CheckField, 3, 2, 0,                   //  8778:    check Inst[4:3] == 0x0
  OPC_Decode, 140, 11, 110,                  //  8782:    decode to VSETALLNEZ_D using decoder 110
                                             //  8782:   }
  49, 4,                                     //  8786:   case 0x31: {
  OPC_Decode, 218, 8, 109,                   //  8788:    decode to VFLOGB_S using decoder 109
                                             //  8788:   }
  50, 4,                                     //  8792:   case 0x32: {
  OPC_Decode, 217, 8, 109,                   //  8794:    decode to VFLOGB_D using decoder 109
                                             //  8794:   }
  53, 4,                                     //  8798:   case 0x35: {
  OPC_Decode, 157, 8, 109,                   //  8800:    decode to VFCLASS_S using decoder 109
                                             //  8800:   }
  54, 4,                                     //  8804:   case 0x36: {
  OPC_Decode, 156, 8, 109,                   //  8806:    decode to VFCLASS_D using decoder 109
                                             //  8806:   }
  57, 4,                                     //  8810:   case 0x39: {
  OPC_Decode, 132, 9, 109,                   //  8812:    decode to VFSQRT_S using decoder 109
                                             //  8812:   }
  58, 4,                                     //  8816:   case 0x3a: {
  OPC_Decode, 131, 9, 109,                   //  8818:    decode to VFSQRT_D using decoder 109
                                             //  8818:   }
  61, 4,                                     //  8822:   case 0x3d: {
  OPC_Decode, 240, 8, 109,                   //  8824:    decode to VFRECIP_S using decoder 109
                                             //  8824:   }
  62, 4,                                     //  8828:   case 0x3e: {
  OPC_Decode, 239, 8, 109,                   //  8830:    decode to VFRECIP_D using decoder 109
                                             //  8830:   }
  65, 4,                                     //  8834:   case 0x41: {
  OPC_Decode, 254, 8, 109,                   //  8836:    decode to VFRSQRT_S using decoder 109
                                             //  8836:   }
  66, 4,                                     //  8840:   case 0x42: {
  OPC_Decode, 253, 8, 109,                   //  8842:    decode to VFRSQRT_D using decoder 109
                                             //  8842:   }
  69, 4,                                     //  8846:   case 0x45: {
  OPC_Decode, 238, 8, 109,                   //  8848:    decode to VFRECIPE_S using decoder 109
                                             //  8848:   }
  70, 4,                                     //  8852:   case 0x46: {
  OPC_Decode, 237, 8, 109,                   //  8854:    decode to VFRECIPE_D using decoder 109
                                             //  8854:   }
  73, 4,                                     //  8858:   case 0x49: {
  OPC_Decode, 252, 8, 109,                   //  8860:    decode to VFRSQRTE_S using decoder 109
                                             //  8860:   }
  74, 4,                                     //  8864:   case 0x4a: {
  OPC_Decode, 251, 8, 109,                   //  8866:    decode to VFRSQRTE_D using decoder 109
                                             //  8866:   }
  77, 4,                                     //  8870:   case 0x4d: {
  OPC_Decode, 250, 8, 109,                   //  8872:    decode to VFRINT_S using decoder 109
                                             //  8872:   }
  78, 4,                                     //  8876:   case 0x4e: {
  OPC_Decode, 249, 8, 109,                   //  8878:    decode to VFRINT_D using decoder 109
                                             //  8878:   }
  81, 4,                                     //  8882:   case 0x51: {
  OPC_Decode, 242, 8, 109,                   //  8884:    decode to VFRINTRM_S using decoder 109
                                             //  8884:   }
  82, 4,                                     //  8888:   case 0x52: {
  OPC_Decode, 241, 8, 109,                   //  8890:    decode to VFRINTRM_D using decoder 109
                                             //  8890:   }
  85, 4,                                     //  8894:   case 0x55: {
  OPC_Decode, 246, 8, 109,                   //  8896:    decode to VFRINTRP_S using decoder 109
                                             //  8896:   }
  86, 4,                                     //  8900:   case 0x56: {
  OPC_Decode, 245, 8, 109,                   //  8902:    decode to VFRINTRP_D using decoder 109
                                             //  8902:   }
  89, 4,                                     //  8906:   case 0x59: {
  OPC_Decode, 248, 8, 109,                   //  8908:    decode to VFRINTRZ_S using decoder 109
                                             //  8908:   }
  90, 4,                                     //  8912:   case 0x5a: {
  OPC_Decode, 247, 8, 109,                   //  8914:    decode to VFRINTRZ_D using decoder 109
                                             //  8914:   }
  93, 4,                                     //  8918:   case 0x5d: {
  OPC_Decode, 244, 8, 109,                   //  8920:    decode to VFRINTRNE_S using decoder 109
                                             //  8920:   }
  94, 4,                                     //  8924:   case 0x5e: {
  OPC_Decode, 243, 8, 109,                   //  8926:    decode to VFRINTRNE_D using decoder 109
                                             //  8926:   }
  122, 4,                                    //  8930:   case 0x7a: {
  OPC_Decode, 205, 8, 109,                   //  8932:    decode to VFCVTL_S_H using decoder 109
                                             //  8932:   }
  123, 4,                                    //  8936:   case 0x7b: {
  OPC_Decode, 203, 8, 109,                   //  8938:    decode to VFCVTH_S_H using decoder 109
                                             //  8938:   }
  124, 4,                                    //  8942:   case 0x7c: {
  OPC_Decode, 204, 8, 109,                   //  8944:    decode to VFCVTL_D_S using decoder 109
                                             //  8944:   }
  125, 4,                                    //  8948:   case 0x7d: {
  OPC_Decode, 202, 8, 109,                   //  8950:    decode to VFCVTH_D_S using decoder 109
                                             //  8950:   }
  128, 1, 4,                                 //  8954:   case 0x80: {
  OPC_Decode, 215, 8, 109,                   //  8957:    decode to VFFINT_S_W using decoder 109
                                             //  8957:   }
  129, 1, 4,                                 //  8961:   case 0x81: {
  OPC_Decode, 216, 8, 109,                   //  8964:    decode to VFFINT_S_WU using decoder 109
                                             //  8964:   }
  130, 1, 4,                                 //  8968:   case 0x82: {
  OPC_Decode, 212, 8, 109,                   //  8971:    decode to VFFINT_D_L using decoder 109
                                             //  8971:   }
  131, 1, 4,                                 //  8975:   case 0x83: {
  OPC_Decode, 213, 8, 109,                   //  8978:    decode to VFFINT_D_LU using decoder 109
                                             //  8978:   }
  132, 1, 4,                                 //  8982:   case 0x84: {
  OPC_Decode, 211, 8, 109,                   //  8985:    decode to VFFINTL_D_W using decoder 109
                                             //  8985:   }
  133, 1, 4,                                 //  8989:   case 0x85: {
  OPC_Decode, 210, 8, 109,                   //  8992:    decode to VFFINTH_D_W using decoder 109
                                             //  8992:   }
  140, 1, 4,                                 //  8996:   case 0x8c: {
  OPC_Decode, 163, 9, 109,                   //  8999:    decode to VFTINT_W_S using decoder 109
                                             //  8999:   }
  141, 1, 4,                                 //  9003:   case 0x8d: {
  OPC_Decode, 160, 9, 109,                   //  9006:    decode to VFTINT_L_D using decoder 109
                                             //  9006:   }
  142, 1, 4,                                 //  9010:   case 0x8e: {
  OPC_Decode, 141, 9, 109,                   //  9013:    decode to VFTINTRM_W_S using decoder 109
                                             //  9013:   }
  143, 1, 4,                                 //  9017:   case 0x8f: {
  OPC_Decode, 139, 9, 109,                   //  9020:    decode to VFTINTRM_L_D using decoder 109
                                             //  9020:   }
  144, 1, 4,                                 //  9024:   case 0x90: {
  OPC_Decode, 151, 9, 109,                   //  9027:    decode to VFTINTRP_W_S using decoder 109
                                             //  9027:   }
  145, 1, 4,                                 //  9031:   case 0x91: {
  OPC_Decode, 149, 9, 109,                   //  9034:    decode to VFTINTRP_L_D using decoder 109
                                             //  9034:   }
  146, 1, 4,                                 //  9038:   case 0x92: {
  OPC_Decode, 158, 9, 109,                   //  9041:    decode to VFTINTRZ_W_S using decoder 109
                                             //  9041:   }
  147, 1, 4,                                 //  9045:   case 0x93: {
  OPC_Decode, 155, 9, 109,                   //  9048:    decode to VFTINTRZ_L_D using decoder 109
                                             //  9048:   }
  148, 1, 4,                                 //  9052:   case 0x94: {
  OPC_Decode, 146, 9, 109,                   //  9055:    decode to VFTINTRNE_W_S using decoder 109
                                             //  9055:   }
  149, 1, 4,                                 //  9059:   case 0x95: {
  OPC_Decode, 144, 9, 109,                   //  9062:    decode to VFTINTRNE_L_D using decoder 109
                                             //  9062:   }
  150, 1, 4,                                 //  9066:   case 0x96: {
  OPC_Decode, 161, 9, 109,                   //  9069:    decode to VFTINT_WU_S using decoder 109
                                             //  9069:   }
  151, 1, 4,                                 //  9073:   case 0x97: {
  OPC_Decode, 159, 9, 109,                   //  9076:    decode to VFTINT_LU_D using decoder 109
                                             //  9076:   }
  156, 1, 4,                                 //  9080:   case 0x9c: {
  OPC_Decode, 156, 9, 109,                   //  9083:    decode to VFTINTRZ_WU_S using decoder 109
                                             //  9083:   }
  157, 1, 4,                                 //  9087:   case 0x9d: {
  OPC_Decode, 154, 9, 109,                   //  9090:    decode to VFTINTRZ_LU_D using decoder 109
                                             //  9090:   }
  160, 1, 4,                                 //  9094:   case 0xa0: {
  OPC_Decode, 136, 9, 109,                   //  9097:    decode to VFTINTL_L_S using decoder 109
                                             //  9097:   }
  161, 1, 4,                                 //  9101:   case 0xa1: {
  OPC_Decode, 135, 9, 109,                   //  9104:    decode to VFTINTH_L_S using decoder 109
                                             //  9104:   }
  162, 1, 4,                                 //  9108:   case 0xa2: {
  OPC_Decode, 138, 9, 109,                   //  9111:    decode to VFTINTRML_L_S using decoder 109
                                             //  9111:   }
  163, 1, 4,                                 //  9115:   case 0xa3: {
  OPC_Decode, 137, 9, 109,                   //  9118:    decode to VFTINTRMH_L_S using decoder 109
                                             //  9118:   }
  164, 1, 4,                                 //  9122:   case 0xa4: {
  OPC_Decode, 148, 9, 109,                   //  9125:    decode to VFTINTRPL_L_S using decoder 109
                                             //  9125:   }
  165, 1, 4,                                 //  9129:   case 0xa5: {
  OPC_Decode, 147, 9, 109,                   //  9132:    decode to VFTINTRPH_L_S using decoder 109
                                             //  9132:   }
  166, 1, 4,                                 //  9136:   case 0xa6: {
  OPC_Decode, 153, 9, 109,                   //  9139:    decode to VFTINTRZL_L_S using decoder 109
                                             //  9139:   }
  167, 1, 4,                                 //  9143:   case 0xa7: {
  OPC_Decode, 152, 9, 109,                   //  9146:    decode to VFTINTRZH_L_S using decoder 109
                                             //  9146:   }
  168, 1, 4,                                 //  9150:   case 0xa8: {
  OPC_Decode, 143, 9, 109,                   //  9153:    decode to VFTINTRNEL_L_S using decoder 109
                                             //  9153:   }
  169, 1, 4,                                 //  9157:   case 0xa9: {
  OPC_Decode, 142, 9, 109,                   //  9160:    decode to VFTINTRNEH_L_S using decoder 109
                                             //  9160:   }
  184, 1, 4,                                 //  9164:   case 0xb8: {
  OPC_Decode, 143, 8, 109,                   //  9167:    decode to VEXTH_H_B using decoder 109
                                             //  9167:   }
  185, 1, 4,                                 //  9171:   case 0xb9: {
  OPC_Decode, 147, 8, 109,                   //  9174:    decode to VEXTH_W_H using decoder 109
                                             //  9174:   }
  186, 1, 4,                                 //  9178:   case 0xba: {
  OPC_Decode, 141, 8, 109,                   //  9181:    decode to VEXTH_D_W using decoder 109
                                             //  9181:   }
  187, 1, 4,                                 //  9185:   case 0xbb: {
  OPC_Decode, 145, 8, 109,                   //  9188:    decode to VEXTH_Q_D using decoder 109
                                             //  9188:   }
  188, 1, 4,                                 //  9192:   case 0xbc: {
  OPC_Decode, 142, 8, 109,                   //  9195:    decode to VEXTH_HU_BU using decoder 109
                                             //  9195:   }
  189, 1, 4,                                 //  9199:   case 0xbd: {
  OPC_Decode, 146, 8, 109,                   //  9202:    decode to VEXTH_WU_HU using decoder 109
                                             //  9202:   }
  190, 1, 4,                                 //  9206:   case 0xbe: {
  OPC_Decode, 140, 8, 109,                   //  9209:    decode to VEXTH_DU_WU using decoder 109
                                             //  9209:   }
  191, 1, 4,                                 //  9213:   case 0xbf: {
  OPC_Decode, 144, 8, 109,                   //  9216:    decode to VEXTH_QU_DU using decoder 109
                                             //  9216:   }
  192, 1, 4,                                 //  9220:   case 0xc0: {
  OPC_Decode, 223, 10, 111,                  //  9223:    decode to VREPLGR2VR_B using decoder 111
                                             //  9223:   }
  193, 1, 4,                                 //  9227:   case 0xc1: {
  OPC_Decode, 225, 10, 111,                  //  9230:    decode to VREPLGR2VR_H using decoder 111
                                             //  9230:   }
  194, 1, 4,                                 //  9234:   case 0xc2: {
  OPC_Decode, 226, 10, 111,                  //  9237:    decode to VREPLGR2VR_W using decoder 111
                                             //  9237:   }
  195, 1, 0,                                 //  9241:   case 0xc3: {
  OPC_Decode, 224, 10, 111,                  //  9244:    decode to VREPLGR2VR_D using decoder 111
                                             //  9244:   }
                                             //  9244:   } // switch Inst[17:10]
                                             //  9244:  }
  168, 1, 41,                                //  9248:  case 0xa8: {
  OPC_SwitchField, 16, 2,                    //  9251:   switch Inst[17:16] {
  0, 30,                                     //  9254:   case 0x0: {
  OPC_SwitchField, 15, 1,                    //  9256:    switch Inst[15] {
  0, 19,                                     //  9259:    case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9261:     switch Inst[14] {
  0, 8,                                      //  9264:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9266:      check Inst[13] == 0x1
  OPC_Decode, 235, 10, 112,                  //  9270:      decode to VROTRI_B using decoder 112
                                             //  9270:     }
  1, 0,                                      //  9274:     case 0x1: {
  OPC_Decode, 237, 10, 113,                  //  9276:      decode to VROTRI_H using decoder 113
                                             //  9276:     }
                                             //  9276:     } // switch Inst[14]
                                             //  9276:    }
  1, 0,                                      //  9280:    case 0x1: {
  OPC_Decode, 238, 10, 107,                  //  9282:     decode to VROTRI_W using decoder 107
                                             //  9282:    }
                                             //  9282:    } // switch Inst[15]
                                             //  9282:   }
  1, 0,                                      //  9286:   case 0x1: {
  OPC_Decode, 236, 10, 114,                  //  9288:    decode to VROTRI_D using decoder 114
                                             //  9288:   }
                                             //  9288:   } // switch Inst[17:16]
                                             //  9288:  }
  169, 1, 41,                                //  9292:  case 0xa9: {
  OPC_SwitchField, 16, 2,                    //  9295:   switch Inst[17:16] {
  0, 30,                                     //  9298:   case 0x0: {
  OPC_SwitchField, 15, 1,                    //  9300:    switch Inst[15] {
  0, 19,                                     //  9303:    case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9305:     switch Inst[14] {
  0, 8,                                      //  9308:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9310:      check Inst[13] == 0x1
  OPC_Decode, 248, 11, 112,                  //  9314:      decode to VSRLRI_B using decoder 112
                                             //  9314:     }
  1, 0,                                      //  9318:     case 0x1: {
  OPC_Decode, 250, 11, 113,                  //  9320:      decode to VSRLRI_H using decoder 113
                                             //  9320:     }
                                             //  9320:     } // switch Inst[14]
                                             //  9320:    }
  1, 0,                                      //  9324:    case 0x1: {
  OPC_Decode, 251, 11, 107,                  //  9326:     decode to VSRLRI_W using decoder 107
                                             //  9326:    }
                                             //  9326:    } // switch Inst[15]
                                             //  9326:   }
  1, 0,                                      //  9330:   case 0x1: {
  OPC_Decode, 249, 11, 114,                  //  9332:    decode to VSRLRI_D using decoder 114
                                             //  9332:   }
                                             //  9332:   } // switch Inst[17:16]
                                             //  9332:  }
  170, 1, 41,                                //  9336:  case 0xaa: {
  OPC_SwitchField, 16, 2,                    //  9339:   switch Inst[17:16] {
  0, 30,                                     //  9342:   case 0x0: {
  OPC_SwitchField, 15, 1,                    //  9344:    switch Inst[15] {
  0, 19,                                     //  9347:    case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9349:     switch Inst[14] {
  0, 8,                                      //  9352:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9354:      check Inst[13] == 0x1
  OPC_Decode, 218, 11, 112,                  //  9358:      decode to VSRARI_B using decoder 112
                                             //  9358:     }
  1, 0,                                      //  9362:     case 0x1: {
  OPC_Decode, 220, 11, 113,                  //  9364:      decode to VSRARI_H using decoder 113
                                             //  9364:     }
                                             //  9364:     } // switch Inst[14]
                                             //  9364:    }
  1, 0,                                      //  9368:    case 0x1: {
  OPC_Decode, 221, 11, 107,                  //  9370:     decode to VSRARI_W using decoder 107
                                             //  9370:    }
                                             //  9370:    } // switch Inst[15]
                                             //  9370:   }
  1, 0,                                      //  9374:   case 0x1: {
  OPC_Decode, 219, 11, 114,                  //  9376:    decode to VSRARI_D using decoder 114
                                             //  9376:   }
                                             //  9376:   } // switch Inst[17:16]
                                             //  9376:  }
  186, 1, 41,                                //  9380:  case 0xba: {
  OPC_SwitchField, 14, 4,                    //  9383:   switch Inst[17:14] {
  14, 4,                                     //  9386:   case 0xe: {
  OPC_Decode, 188, 9, 115,                   //  9388:    decode to VINSGR2VR_B using decoder 115
                                             //  9388:   }
  15, 0,                                     //  9392:   case 0xf: {
  OPC_SwitchField, 13, 1,                    //  9394:    switch Inst[13] {
  0, 4,                                      //  9397:    case 0x0: {
  OPC_Decode, 190, 9, 116,                   //  9399:     decode to VINSGR2VR_H using decoder 116
                                             //  9399:    }
  1, 0,                                      //  9403:    case 0x1: {
  OPC_SwitchField, 12, 1,                    //  9405:     switch Inst[12] {
  0, 4,                                      //  9408:     case 0x0: {
  OPC_Decode, 191, 9, 117,                   //  9410:      decode to VINSGR2VR_W using decoder 117
                                             //  9410:     }
  1, 0,                                      //  9414:     case 0x1: {
  OPC_CheckField, 11, 1, 0,                  //  9416:      check Inst[11] == 0x0
  OPC_Decode, 189, 9, 118,                   //  9420:      decode to VINSGR2VR_D using decoder 118
                                             //  9420:     }
                                             //  9420:     } // switch Inst[12]
                                             //  9420:    }
                                             //  9420:    } // switch Inst[13]
                                             //  9420:   }
                                             //  9420:   } // switch Inst[17:14]
                                             //  9420:  }
  187, 1, 41,                                //  9424:  case 0xbb: {
  OPC_SwitchField, 14, 4,                    //  9427:   switch Inst[17:14] {
  14, 4,                                     //  9430:   case 0xe: {
  OPC_Decode, 215, 10, 119,                  //  9432:    decode to VPICKVE2GR_B using decoder 119
                                             //  9432:   }
  15, 0,                                     //  9436:   case 0xf: {
  OPC_SwitchField, 13, 1,                    //  9438:    switch Inst[13] {
  0, 4,                                      //  9441:    case 0x0: {
  OPC_Decode, 219, 10, 120,                  //  9443:     decode to VPICKVE2GR_H using decoder 120
                                             //  9443:    }
  1, 0,                                      //  9447:    case 0x1: {
  OPC_SwitchField, 12, 1,                    //  9449:     switch Inst[12] {
  0, 4,                                      //  9452:     case 0x0: {
  OPC_Decode, 221, 10, 121,                  //  9454:      decode to VPICKVE2GR_W using decoder 121
                                             //  9454:     }
  1, 0,                                      //  9458:     case 0x1: {
  OPC_CheckField, 11, 1, 0,                  //  9460:      check Inst[11] == 0x0
  OPC_Decode, 217, 10, 122,                  //  9464:      decode to VPICKVE2GR_D using decoder 122
                                             //  9464:     }
                                             //  9464:     } // switch Inst[12]
                                             //  9464:    }
                                             //  9464:    } // switch Inst[13]
                                             //  9464:   }
                                             //  9464:   } // switch Inst[17:14]
                                             //  9464:  }
  188, 1, 41,                                //  9468:  case 0xbc: {
  OPC_SwitchField, 14, 4,                    //  9471:   switch Inst[17:14] {
  14, 4,                                     //  9474:   case 0xe: {
  OPC_Decode, 216, 10, 119,                  //  9476:    decode to VPICKVE2GR_BU using decoder 119
                                             //  9476:   }
  15, 0,                                     //  9480:   case 0xf: {
  OPC_SwitchField, 13, 1,                    //  9482:    switch Inst[13] {
  0, 4,                                      //  9485:    case 0x0: {
  OPC_Decode, 220, 10, 120,                  //  9487:     decode to VPICKVE2GR_HU using decoder 120
                                             //  9487:    }
  1, 0,                                      //  9491:    case 0x1: {
  OPC_SwitchField, 12, 1,                    //  9493:     switch Inst[12] {
  0, 4,                                      //  9496:     case 0x0: {
  OPC_Decode, 222, 10, 121,                  //  9498:      decode to VPICKVE2GR_WU using decoder 121
                                             //  9498:     }
  1, 0,                                      //  9502:     case 0x1: {
  OPC_CheckField, 11, 1, 0,                  //  9504:      check Inst[11] == 0x0
  OPC_Decode, 218, 10, 122,                  //  9508:      decode to VPICKVE2GR_DU using decoder 122
                                             //  9508:     }
                                             //  9508:     } // switch Inst[12]
                                             //  9508:    }
                                             //  9508:    } // switch Inst[13]
                                             //  9508:   }
                                             //  9508:   } // switch Inst[17:14]
                                             //  9508:  }
  189, 1, 41,                                //  9512:  case 0xbd: {
  OPC_SwitchField, 14, 4,                    //  9515:   switch Inst[17:14] {
  14, 4,                                     //  9518:   case 0xe: {
  OPC_Decode, 227, 10, 113,                  //  9520:    decode to VREPLVEI_B using decoder 113
                                             //  9520:   }
  15, 0,                                     //  9524:   case 0xf: {
  OPC_SwitchField, 13, 1,                    //  9526:    switch Inst[13] {
  0, 4,                                      //  9529:    case 0x0: {
  OPC_Decode, 229, 10, 112,                  //  9531:     decode to VREPLVEI_H using decoder 112
                                             //  9531:    }
  1, 0,                                      //  9535:    case 0x1: {
  OPC_SwitchField, 12, 1,                    //  9537:     switch Inst[12] {
  0, 4,                                      //  9540:     case 0x0: {
  OPC_Decode, 230, 10, 123,                  //  9542:      decode to VREPLVEI_W using decoder 123
                                             //  9542:     }
  1, 0,                                      //  9546:     case 0x1: {
  OPC_CheckField, 11, 1, 0,                  //  9548:      check Inst[11] == 0x0
  OPC_Decode, 228, 10, 124,                  //  9552:      decode to VREPLVEI_D using decoder 124
                                             //  9552:     }
                                             //  9552:     } // switch Inst[12]
                                             //  9552:    }
                                             //  9552:    } // switch Inst[13]
                                             //  9552:   }
                                             //  9552:   } // switch Inst[17:14]
                                             //  9552:  }
  194, 1, 40,                                //  9556:  case 0xc2: {
  OPC_SwitchField, 15, 3,                    //  9559:   switch Inst[17:15] {
  0, 19,                                     //  9562:   case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9564:    switch Inst[14] {
  0, 8,                                      //  9567:    case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9569:     check Inst[13] == 0x1
  OPC_Decode, 184, 11, 112,                  //  9573:     decode to VSLLWIL_H_B using decoder 112
                                             //  9573:    }
  1, 0,                                      //  9577:    case 0x1: {
  OPC_Decode, 186, 11, 113,                  //  9579:     decode to VSLLWIL_W_H using decoder 113
                                             //  9579:    }
                                             //  9579:    } // switch Inst[14]
                                             //  9579:   }
  1, 4,                                      //  9583:   case 0x1: {
  OPC_Decode, 182, 11, 107,                  //  9585:    decode to VSLLWIL_D_W using decoder 107
                                             //  9585:   }
  2, 0,                                      //  9589:   case 0x2: {
  OPC_CheckField, 10, 5, 0,                  //  9591:    check Inst[14:10] == 0x0
  OPC_Decode, 149, 8, 109,                   //  9595:    decode to VEXTL_Q_D using decoder 109
                                             //  9595:   }
                                             //  9595:   } // switch Inst[17:15]
                                             //  9595:  }
  195, 1, 40,                                //  9599:  case 0xc3: {
  OPC_SwitchField, 15, 3,                    //  9602:   switch Inst[17:15] {
  0, 19,                                     //  9605:   case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9607:    switch Inst[14] {
  0, 8,                                      //  9610:    case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9612:     check Inst[13] == 0x1
  OPC_Decode, 183, 11, 112,                  //  9616:     decode to VSLLWIL_HU_BU using decoder 112
                                             //  9616:    }
  1, 0,                                      //  9620:    case 0x1: {
  OPC_Decode, 185, 11, 113,                  //  9622:     decode to VSLLWIL_WU_HU using decoder 113
                                             //  9622:    }
                                             //  9622:    } // switch Inst[14]
                                             //  9622:   }
  1, 4,                                      //  9626:   case 0x1: {
  OPC_Decode, 181, 11, 107,                  //  9628:    decode to VSLLWIL_DU_WU using decoder 107
                                             //  9628:   }
  2, 0,                                      //  9632:   case 0x2: {
  OPC_CheckField, 10, 5, 0,                  //  9634:    check Inst[14:10] == 0x0
  OPC_Decode, 148, 8, 109,                   //  9638:    decode to VEXTL_QU_DU using decoder 109
                                             //  9638:   }
                                             //  9638:   } // switch Inst[17:15]
                                             //  9638:  }
  196, 1, 41,                                //  9642:  case 0xc4: {
  OPC_SwitchField, 16, 2,                    //  9645:   switch Inst[17:16] {
  0, 30,                                     //  9648:   case 0x0: {
  OPC_SwitchField, 15, 1,                    //  9650:    switch Inst[15] {
  0, 19,                                     //  9653:    case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9655:     switch Inst[14] {
  0, 8,                                      //  9658:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9660:      check Inst[13] == 0x1
  OPC_Decode, 212, 7, 112,                   //  9664:      decode to VBITCLRI_B using decoder 112
                                             //  9664:     }
  1, 0,                                      //  9668:     case 0x1: {
  OPC_Decode, 214, 7, 113,                   //  9670:      decode to VBITCLRI_H using decoder 113
                                             //  9670:     }
                                             //  9670:     } // switch Inst[14]
                                             //  9670:    }
  1, 0,                                      //  9674:    case 0x1: {
  OPC_Decode, 215, 7, 107,                   //  9676:     decode to VBITCLRI_W using decoder 107
                                             //  9676:    }
                                             //  9676:    } // switch Inst[15]
                                             //  9676:   }
  1, 0,                                      //  9680:   case 0x1: {
  OPC_Decode, 213, 7, 114,                   //  9682:    decode to VBITCLRI_D using decoder 114
                                             //  9682:   }
                                             //  9682:   } // switch Inst[17:16]
                                             //  9682:  }
  197, 1, 41,                                //  9686:  case 0xc5: {
  OPC_SwitchField, 16, 2,                    //  9689:   switch Inst[17:16] {
  0, 30,                                     //  9692:   case 0x0: {
  OPC_SwitchField, 15, 1,                    //  9694:    switch Inst[15] {
  0, 19,                                     //  9697:    case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9699:     switch Inst[14] {
  0, 8,                                      //  9702:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9704:      check Inst[13] == 0x1
  OPC_Decode, 230, 7, 112,                   //  9708:      decode to VBITSETI_B using decoder 112
                                             //  9708:     }
  1, 0,                                      //  9712:     case 0x1: {
  OPC_Decode, 232, 7, 113,                   //  9714:      decode to VBITSETI_H using decoder 113
                                             //  9714:     }
                                             //  9714:     } // switch Inst[14]
                                             //  9714:    }
  1, 0,                                      //  9718:    case 0x1: {
  OPC_Decode, 233, 7, 107,                   //  9720:     decode to VBITSETI_W using decoder 107
                                             //  9720:    }
                                             //  9720:    } // switch Inst[15]
                                             //  9720:   }
  1, 0,                                      //  9724:   case 0x1: {
  OPC_Decode, 231, 7, 114,                   //  9726:    decode to VBITSETI_D using decoder 114
                                             //  9726:   }
                                             //  9726:   } // switch Inst[17:16]
                                             //  9726:  }
  198, 1, 41,                                //  9730:  case 0xc6: {
  OPC_SwitchField, 16, 2,                    //  9733:   switch Inst[17:16] {
  0, 30,                                     //  9736:   case 0x0: {
  OPC_SwitchField, 15, 1,                    //  9738:    switch Inst[15] {
  0, 19,                                     //  9741:    case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9743:     switch Inst[14] {
  0, 8,                                      //  9746:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9748:      check Inst[13] == 0x1
  OPC_Decode, 220, 7, 112,                   //  9752:      decode to VBITREVI_B using decoder 112
                                             //  9752:     }
  1, 0,                                      //  9756:     case 0x1: {
  OPC_Decode, 222, 7, 113,                   //  9758:      decode to VBITREVI_H using decoder 113
                                             //  9758:     }
                                             //  9758:     } // switch Inst[14]
                                             //  9758:    }
  1, 0,                                      //  9762:    case 0x1: {
  OPC_Decode, 223, 7, 107,                   //  9764:     decode to VBITREVI_W using decoder 107
                                             //  9764:    }
                                             //  9764:    } // switch Inst[15]
                                             //  9764:   }
  1, 0,                                      //  9768:   case 0x1: {
  OPC_Decode, 221, 7, 114,                   //  9770:    decode to VBITREVI_D using decoder 114
                                             //  9770:   }
                                             //  9770:   } // switch Inst[17:16]
                                             //  9770:  }
  201, 1, 41,                                //  9774:  case 0xc9: {
  OPC_SwitchField, 16, 2,                    //  9777:   switch Inst[17:16] {
  0, 30,                                     //  9780:   case 0x0: {
  OPC_SwitchField, 15, 1,                    //  9782:    switch Inst[15] {
  0, 19,                                     //  9785:    case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9787:     switch Inst[14] {
  0, 8,                                      //  9790:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9792:      check Inst[13] == 0x1
  OPC_Decode, 251, 10, 112,                  //  9796:      decode to VSAT_B using decoder 112
                                             //  9796:     }
  1, 0,                                      //  9800:     case 0x1: {
  OPC_Decode, 255, 10, 113,                  //  9802:      decode to VSAT_H using decoder 113
                                             //  9802:     }
                                             //  9802:     } // switch Inst[14]
                                             //  9802:    }
  1, 0,                                      //  9806:    case 0x1: {
  OPC_Decode, 129, 11, 107,                  //  9808:     decode to VSAT_W using decoder 107
                                             //  9808:    }
                                             //  9808:    } // switch Inst[15]
                                             //  9808:   }
  1, 0,                                      //  9812:   case 0x1: {
  OPC_Decode, 253, 10, 114,                  //  9814:    decode to VSAT_D using decoder 114
                                             //  9814:   }
                                             //  9814:   } // switch Inst[17:16]
                                             //  9814:  }
  202, 1, 41,                                //  9818:  case 0xca: {
  OPC_SwitchField, 16, 2,                    //  9821:   switch Inst[17:16] {
  0, 30,                                     //  9824:   case 0x0: {
  OPC_SwitchField, 15, 1,                    //  9826:    switch Inst[15] {
  0, 19,                                     //  9829:    case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9831:     switch Inst[14] {
  0, 8,                                      //  9834:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9836:      check Inst[13] == 0x1
  OPC_Decode, 252, 10, 112,                  //  9840:      decode to VSAT_BU using decoder 112
                                             //  9840:     }
  1, 0,                                      //  9844:     case 0x1: {
  OPC_Decode, 128, 11, 113,                  //  9846:      decode to VSAT_HU using decoder 113
                                             //  9846:     }
                                             //  9846:     } // switch Inst[14]
                                             //  9846:    }
  1, 0,                                      //  9850:    case 0x1: {
  OPC_Decode, 130, 11, 107,                  //  9852:     decode to VSAT_WU using decoder 107
                                             //  9852:    }
                                             //  9852:    } // switch Inst[15]
                                             //  9852:   }
  1, 0,                                      //  9856:   case 0x1: {
  OPC_Decode, 254, 10, 114,                  //  9858:    decode to VSAT_DU using decoder 114
                                             //  9858:   }
                                             //  9858:   } // switch Inst[17:16]
                                             //  9858:  }
  203, 1, 41,                                //  9862:  case 0xcb: {
  OPC_SwitchField, 16, 2,                    //  9865:   switch Inst[17:16] {
  0, 30,                                     //  9868:   case 0x0: {
  OPC_SwitchField, 15, 1,                    //  9870:    switch Inst[15] {
  0, 19,                                     //  9873:    case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9875:     switch Inst[14] {
  0, 8,                                      //  9878:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9880:      check Inst[13] == 0x1
  OPC_Decode, 177, 11, 112,                  //  9884:      decode to VSLLI_B using decoder 112
                                             //  9884:     }
  1, 0,                                      //  9888:     case 0x1: {
  OPC_Decode, 179, 11, 113,                  //  9890:      decode to VSLLI_H using decoder 113
                                             //  9890:     }
                                             //  9890:     } // switch Inst[14]
                                             //  9890:    }
  1, 0,                                      //  9894:    case 0x1: {
  OPC_Decode, 180, 11, 107,                  //  9896:     decode to VSLLI_W using decoder 107
                                             //  9896:    }
                                             //  9896:    } // switch Inst[15]
                                             //  9896:   }
  1, 0,                                      //  9900:   case 0x1: {
  OPC_Decode, 178, 11, 114,                  //  9902:    decode to VSLLI_D using decoder 114
                                             //  9902:   }
                                             //  9902:   } // switch Inst[17:16]
                                             //  9902:  }
  204, 1, 41,                                //  9906:  case 0xcc: {
  OPC_SwitchField, 16, 2,                    //  9909:   switch Inst[17:16] {
  0, 30,                                     //  9912:   case 0x0: {
  OPC_SwitchField, 15, 1,                    //  9914:    switch Inst[15] {
  0, 19,                                     //  9917:    case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9919:     switch Inst[14] {
  0, 8,                                      //  9922:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9924:      check Inst[13] == 0x1
  OPC_Decode, 237, 11, 112,                  //  9928:      decode to VSRLI_B using decoder 112
                                             //  9928:     }
  1, 0,                                      //  9932:     case 0x1: {
  OPC_Decode, 239, 11, 113,                  //  9934:      decode to VSRLI_H using decoder 113
                                             //  9934:     }
                                             //  9934:     } // switch Inst[14]
                                             //  9934:    }
  1, 0,                                      //  9938:    case 0x1: {
  OPC_Decode, 240, 11, 107,                  //  9940:     decode to VSRLI_W using decoder 107
                                             //  9940:    }
                                             //  9940:    } // switch Inst[15]
                                             //  9940:   }
  1, 0,                                      //  9944:   case 0x1: {
  OPC_Decode, 238, 11, 114,                  //  9946:    decode to VSRLI_D using decoder 114
                                             //  9946:   }
                                             //  9946:   } // switch Inst[17:16]
                                             //  9946:  }
  205, 1, 41,                                //  9950:  case 0xcd: {
  OPC_SwitchField, 16, 2,                    //  9953:   switch Inst[17:16] {
  0, 30,                                     //  9956:   case 0x0: {
  OPC_SwitchField, 15, 1,                    //  9958:    switch Inst[15] {
  0, 19,                                     //  9961:    case 0x0: {
  OPC_SwitchField, 14, 1,                    //  9963:     switch Inst[14] {
  0, 8,                                      //  9966:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  //  9968:      check Inst[13] == 0x1
  OPC_Decode, 207, 11, 112,                  //  9972:      decode to VSRAI_B using decoder 112
                                             //  9972:     }
  1, 0,                                      //  9976:     case 0x1: {
  OPC_Decode, 209, 11, 113,                  //  9978:      decode to VSRAI_H using decoder 113
                                             //  9978:     }
                                             //  9978:     } // switch Inst[14]
                                             //  9978:    }
  1, 0,                                      //  9982:    case 0x1: {
  OPC_Decode, 210, 11, 107,                  //  9984:     decode to VSRAI_W using decoder 107
                                             //  9984:    }
                                             //  9984:    } // switch Inst[15]
                                             //  9984:   }
  1, 0,                                      //  9988:   case 0x1: {
  OPC_Decode, 208, 11, 114,                  //  9990:    decode to VSRAI_D using decoder 114
                                             //  9990:   }
                                             //  9990:   } // switch Inst[17:16]
                                             //  9990:  }
  208, 1, 41,                                //  9994:  case 0xd0: {
  OPC_SwitchField, 17, 1,                    //  9997:   switch Inst[17] {
  0, 30,                                     // 10000:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10002:    switch Inst[16] {
  0, 19,                                     // 10005:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10007:     switch Inst[15] {
  0, 8,                                      // 10010:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10012:      check Inst[14] == 0x1
  OPC_Decode, 241, 11, 125,                  // 10016:      decode to VSRLNI_B_H using decoder 125
                                             // 10016:     }
  1, 0,                                      // 10020:     case 0x1: {
  OPC_Decode, 243, 11, 108,                  // 10022:      decode to VSRLNI_H_W using decoder 108
                                             // 10022:     }
                                             // 10022:     } // switch Inst[15]
                                             // 10022:    }
  1, 0,                                      // 10026:    case 0x1: {
  OPC_Decode, 244, 11, 126,                  // 10028:     decode to VSRLNI_W_D using decoder 126
                                             // 10028:    }
                                             // 10028:    } // switch Inst[16]
                                             // 10028:   }
  1, 0,                                      // 10032:   case 0x1: {
  OPC_Decode, 242, 11, 127,                  // 10034:    decode to VSRLNI_D_Q using decoder 127
                                             // 10034:   }
                                             // 10034:   } // switch Inst[17]
                                             // 10034:  }
  209, 1, 41,                                // 10038:  case 0xd1: {
  OPC_SwitchField, 17, 1,                    // 10041:   switch Inst[17] {
  0, 30,                                     // 10044:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10046:    switch Inst[16] {
  0, 19,                                     // 10049:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10051:     switch Inst[15] {
  0, 8,                                      // 10054:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10056:      check Inst[14] == 0x1
  OPC_Decode, 252, 11, 125,                  // 10060:      decode to VSRLRNI_B_H using decoder 125
                                             // 10060:     }
  1, 0,                                      // 10064:     case 0x1: {
  OPC_Decode, 254, 11, 108,                  // 10066:      decode to VSRLRNI_H_W using decoder 108
                                             // 10066:     }
                                             // 10066:     } // switch Inst[15]
                                             // 10066:    }
  1, 0,                                      // 10070:    case 0x1: {
  OPC_Decode, 255, 11, 126,                  // 10072:     decode to VSRLRNI_W_D using decoder 126
                                             // 10072:    }
                                             // 10072:    } // switch Inst[16]
                                             // 10072:   }
  1, 0,                                      // 10076:   case 0x1: {
  OPC_Decode, 253, 11, 127,                  // 10078:    decode to VSRLRNI_D_Q using decoder 127
                                             // 10078:   }
                                             // 10078:   } // switch Inst[17]
                                             // 10078:  }
  210, 1, 41,                                // 10082:  case 0xd2: {
  OPC_SwitchField, 17, 1,                    // 10085:   switch Inst[17] {
  0, 30,                                     // 10088:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10090:    switch Inst[16] {
  0, 19,                                     // 10093:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10095:     switch Inst[15] {
  0, 8,                                      // 10098:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10100:      check Inst[14] == 0x1
  OPC_Decode, 168, 12, 125,                  // 10104:      decode to VSSRLNI_B_H using decoder 125
                                             // 10104:     }
  1, 0,                                      // 10108:     case 0x1: {
  OPC_Decode, 172, 12, 108,                  // 10110:      decode to VSSRLNI_H_W using decoder 108
                                             // 10110:     }
                                             // 10110:     } // switch Inst[15]
                                             // 10110:    }
  1, 0,                                      // 10114:    case 0x1: {
  OPC_Decode, 174, 12, 126,                  // 10116:     decode to VSSRLNI_W_D using decoder 126
                                             // 10116:    }
                                             // 10116:    } // switch Inst[16]
                                             // 10116:   }
  1, 0,                                      // 10120:   case 0x1: {
  OPC_Decode, 170, 12, 127,                  // 10122:    decode to VSSRLNI_D_Q using decoder 127
                                             // 10122:   }
                                             // 10122:   } // switch Inst[17]
                                             // 10122:  }
  211, 1, 41,                                // 10126:  case 0xd3: {
  OPC_SwitchField, 17, 1,                    // 10129:   switch Inst[17] {
  0, 30,                                     // 10132:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10134:    switch Inst[16] {
  0, 19,                                     // 10137:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10139:     switch Inst[15] {
  0, 8,                                      // 10142:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10144:      check Inst[14] == 0x1
  OPC_Decode, 167, 12, 125,                  // 10148:      decode to VSSRLNI_BU_H using decoder 125
                                             // 10148:     }
  1, 0,                                      // 10152:     case 0x1: {
  OPC_Decode, 171, 12, 108,                  // 10154:      decode to VSSRLNI_HU_W using decoder 108
                                             // 10154:     }
                                             // 10154:     } // switch Inst[15]
                                             // 10154:    }
  1, 0,                                      // 10158:    case 0x1: {
  OPC_Decode, 173, 12, 126,                  // 10160:     decode to VSSRLNI_WU_D using decoder 126
                                             // 10160:    }
                                             // 10160:    } // switch Inst[16]
                                             // 10160:   }
  1, 0,                                      // 10164:   case 0x1: {
  OPC_Decode, 169, 12, 127,                  // 10166:    decode to VSSRLNI_DU_Q using decoder 127
                                             // 10166:   }
                                             // 10166:   } // switch Inst[17]
                                             // 10166:  }
  212, 1, 41,                                // 10170:  case 0xd4: {
  OPC_SwitchField, 17, 1,                    // 10173:   switch Inst[17] {
  0, 30,                                     // 10176:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10178:    switch Inst[16] {
  0, 19,                                     // 10181:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10183:     switch Inst[15] {
  0, 8,                                      // 10186:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10188:      check Inst[14] == 0x1
  OPC_Decode, 182, 12, 125,                  // 10192:      decode to VSSRLRNI_B_H using decoder 125
                                             // 10192:     }
  1, 0,                                      // 10196:     case 0x1: {
  OPC_Decode, 186, 12, 108,                  // 10198:      decode to VSSRLRNI_H_W using decoder 108
                                             // 10198:     }
                                             // 10198:     } // switch Inst[15]
                                             // 10198:    }
  1, 0,                                      // 10202:    case 0x1: {
  OPC_Decode, 188, 12, 126,                  // 10204:     decode to VSSRLRNI_W_D using decoder 126
                                             // 10204:    }
                                             // 10204:    } // switch Inst[16]
                                             // 10204:   }
  1, 0,                                      // 10208:   case 0x1: {
  OPC_Decode, 184, 12, 127,                  // 10210:    decode to VSSRLRNI_D_Q using decoder 127
                                             // 10210:   }
                                             // 10210:   } // switch Inst[17]
                                             // 10210:  }
  213, 1, 41,                                // 10214:  case 0xd5: {
  OPC_SwitchField, 17, 1,                    // 10217:   switch Inst[17] {
  0, 30,                                     // 10220:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10222:    switch Inst[16] {
  0, 19,                                     // 10225:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10227:     switch Inst[15] {
  0, 8,                                      // 10230:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10232:      check Inst[14] == 0x1
  OPC_Decode, 181, 12, 125,                  // 10236:      decode to VSSRLRNI_BU_H using decoder 125
                                             // 10236:     }
  1, 0,                                      // 10240:     case 0x1: {
  OPC_Decode, 185, 12, 108,                  // 10242:      decode to VSSRLRNI_HU_W using decoder 108
                                             // 10242:     }
                                             // 10242:     } // switch Inst[15]
                                             // 10242:    }
  1, 0,                                      // 10246:    case 0x1: {
  OPC_Decode, 187, 12, 126,                  // 10248:     decode to VSSRLRNI_WU_D using decoder 126
                                             // 10248:    }
                                             // 10248:    } // switch Inst[16]
                                             // 10248:   }
  1, 0,                                      // 10252:   case 0x1: {
  OPC_Decode, 183, 12, 127,                  // 10254:    decode to VSSRLRNI_DU_Q using decoder 127
                                             // 10254:   }
                                             // 10254:   } // switch Inst[17]
                                             // 10254:  }
  214, 1, 41,                                // 10258:  case 0xd6: {
  OPC_SwitchField, 17, 1,                    // 10261:   switch Inst[17] {
  0, 30,                                     // 10264:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10266:    switch Inst[16] {
  0, 19,                                     // 10269:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10271:     switch Inst[15] {
  0, 8,                                      // 10274:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10276:      check Inst[14] == 0x1
  OPC_Decode, 211, 11, 125,                  // 10280:      decode to VSRANI_B_H using decoder 125
                                             // 10280:     }
  1, 0,                                      // 10284:     case 0x1: {
  OPC_Decode, 213, 11, 108,                  // 10286:      decode to VSRANI_H_W using decoder 108
                                             // 10286:     }
                                             // 10286:     } // switch Inst[15]
                                             // 10286:    }
  1, 0,                                      // 10290:    case 0x1: {
  OPC_Decode, 214, 11, 126,                  // 10292:     decode to VSRANI_W_D using decoder 126
                                             // 10292:    }
                                             // 10292:    } // switch Inst[16]
                                             // 10292:   }
  1, 0,                                      // 10296:   case 0x1: {
  OPC_Decode, 212, 11, 127,                  // 10298:    decode to VSRANI_D_Q using decoder 127
                                             // 10298:   }
                                             // 10298:   } // switch Inst[17]
                                             // 10298:  }
  215, 1, 41,                                // 10302:  case 0xd7: {
  OPC_SwitchField, 17, 1,                    // 10305:   switch Inst[17] {
  0, 30,                                     // 10308:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10310:    switch Inst[16] {
  0, 19,                                     // 10313:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10315:     switch Inst[15] {
  0, 8,                                      // 10318:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10320:      check Inst[14] == 0x1
  OPC_Decode, 222, 11, 125,                  // 10324:      decode to VSRARNI_B_H using decoder 125
                                             // 10324:     }
  1, 0,                                      // 10328:     case 0x1: {
  OPC_Decode, 224, 11, 108,                  // 10330:      decode to VSRARNI_H_W using decoder 108
                                             // 10330:     }
                                             // 10330:     } // switch Inst[15]
                                             // 10330:    }
  1, 0,                                      // 10334:    case 0x1: {
  OPC_Decode, 225, 11, 126,                  // 10336:     decode to VSRARNI_W_D using decoder 126
                                             // 10336:    }
                                             // 10336:    } // switch Inst[16]
                                             // 10336:   }
  1, 0,                                      // 10340:   case 0x1: {
  OPC_Decode, 223, 11, 127,                  // 10342:    decode to VSRARNI_D_Q using decoder 127
                                             // 10342:   }
                                             // 10342:   } // switch Inst[17]
                                             // 10342:  }
  216, 1, 41,                                // 10346:  case 0xd8: {
  OPC_SwitchField, 17, 1,                    // 10349:   switch Inst[17] {
  0, 30,                                     // 10352:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10354:    switch Inst[16] {
  0, 19,                                     // 10357:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10359:     switch Inst[15] {
  0, 8,                                      // 10362:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10364:      check Inst[14] == 0x1
  OPC_Decode, 140, 12, 125,                  // 10368:      decode to VSSRANI_B_H using decoder 125
                                             // 10368:     }
  1, 0,                                      // 10372:     case 0x1: {
  OPC_Decode, 144, 12, 108,                  // 10374:      decode to VSSRANI_H_W using decoder 108
                                             // 10374:     }
                                             // 10374:     } // switch Inst[15]
                                             // 10374:    }
  1, 0,                                      // 10378:    case 0x1: {
  OPC_Decode, 146, 12, 126,                  // 10380:     decode to VSSRANI_W_D using decoder 126
                                             // 10380:    }
                                             // 10380:    } // switch Inst[16]
                                             // 10380:   }
  1, 0,                                      // 10384:   case 0x1: {
  OPC_Decode, 142, 12, 127,                  // 10386:    decode to VSSRANI_D_Q using decoder 127
                                             // 10386:   }
                                             // 10386:   } // switch Inst[17]
                                             // 10386:  }
  217, 1, 41,                                // 10390:  case 0xd9: {
  OPC_SwitchField, 17, 1,                    // 10393:   switch Inst[17] {
  0, 30,                                     // 10396:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10398:    switch Inst[16] {
  0, 19,                                     // 10401:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10403:     switch Inst[15] {
  0, 8,                                      // 10406:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10408:      check Inst[14] == 0x1
  OPC_Decode, 139, 12, 125,                  // 10412:      decode to VSSRANI_BU_H using decoder 125
                                             // 10412:     }
  1, 0,                                      // 10416:     case 0x1: {
  OPC_Decode, 143, 12, 108,                  // 10418:      decode to VSSRANI_HU_W using decoder 108
                                             // 10418:     }
                                             // 10418:     } // switch Inst[15]
                                             // 10418:    }
  1, 0,                                      // 10422:    case 0x1: {
  OPC_Decode, 145, 12, 126,                  // 10424:     decode to VSSRANI_WU_D using decoder 126
                                             // 10424:    }
                                             // 10424:    } // switch Inst[16]
                                             // 10424:   }
  1, 0,                                      // 10428:   case 0x1: {
  OPC_Decode, 141, 12, 127,                  // 10430:    decode to VSSRANI_DU_Q using decoder 127
                                             // 10430:   }
                                             // 10430:   } // switch Inst[17]
                                             // 10430:  }
  218, 1, 41,                                // 10434:  case 0xda: {
  OPC_SwitchField, 17, 1,                    // 10437:   switch Inst[17] {
  0, 30,                                     // 10440:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10442:    switch Inst[16] {
  0, 19,                                     // 10445:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10447:     switch Inst[15] {
  0, 8,                                      // 10450:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10452:      check Inst[14] == 0x1
  OPC_Decode, 154, 12, 125,                  // 10456:      decode to VSSRARNI_B_H using decoder 125
                                             // 10456:     }
  1, 0,                                      // 10460:     case 0x1: {
  OPC_Decode, 158, 12, 108,                  // 10462:      decode to VSSRARNI_H_W using decoder 108
                                             // 10462:     }
                                             // 10462:     } // switch Inst[15]
                                             // 10462:    }
  1, 0,                                      // 10466:    case 0x1: {
  OPC_Decode, 160, 12, 126,                  // 10468:     decode to VSSRARNI_W_D using decoder 126
                                             // 10468:    }
                                             // 10468:    } // switch Inst[16]
                                             // 10468:   }
  1, 0,                                      // 10472:   case 0x1: {
  OPC_Decode, 156, 12, 127,                  // 10474:    decode to VSSRARNI_D_Q using decoder 127
                                             // 10474:   }
                                             // 10474:   } // switch Inst[17]
                                             // 10474:  }
  219, 1, 41,                                // 10478:  case 0xdb: {
  OPC_SwitchField, 17, 1,                    // 10481:   switch Inst[17] {
  0, 30,                                     // 10484:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 10486:    switch Inst[16] {
  0, 19,                                     // 10489:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 10491:     switch Inst[15] {
  0, 8,                                      // 10494:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 10496:      check Inst[14] == 0x1
  OPC_Decode, 153, 12, 125,                  // 10500:      decode to VSSRARNI_BU_H using decoder 125
                                             // 10500:     }
  1, 0,                                      // 10504:     case 0x1: {
  OPC_Decode, 157, 12, 108,                  // 10506:      decode to VSSRARNI_HU_W using decoder 108
                                             // 10506:     }
                                             // 10506:     } // switch Inst[15]
                                             // 10506:    }
  1, 0,                                      // 10510:    case 0x1: {
  OPC_Decode, 159, 12, 126,                  // 10512:     decode to VSSRARNI_WU_D using decoder 126
                                             // 10512:    }
                                             // 10512:    } // switch Inst[16]
                                             // 10512:   }
  1, 0,                                      // 10516:   case 0x1: {
  OPC_Decode, 155, 12, 127,                  // 10518:    decode to VSSRARNI_DU_Q using decoder 127
                                             // 10518:   }
                                             // 10518:   } // switch Inst[17]
                                             // 10518:  }
  224, 1, 5,                                 // 10522:  case 0xe0: {
  OPC_Decode, 151, 8, 128, 1,                // 10525:   decode to VEXTRINS_D using decoder 128
                                             // 10525:  }
  225, 1, 5,                                 // 10530:  case 0xe1: {
  OPC_Decode, 153, 8, 128, 1,                // 10533:   decode to VEXTRINS_W using decoder 128
                                             // 10533:  }
  226, 1, 5,                                 // 10538:  case 0xe2: {
  OPC_Decode, 152, 8, 128, 1,                // 10541:   decode to VEXTRINS_H using decoder 128
                                             // 10541:  }
  227, 1, 5,                                 // 10546:  case 0xe3: {
  OPC_Decode, 150, 8, 128, 1,                // 10549:   decode to VEXTRINS_B using decoder 128
                                             // 10549:  }
  228, 1, 5,                                 // 10554:  case 0xe4: {
  OPC_Decode, 149, 11, 129, 1,               // 10557:   decode to VSHUF4I_B using decoder 129
                                             // 10557:  }
  229, 1, 5,                                 // 10562:  case 0xe5: {
  OPC_Decode, 151, 11, 129, 1,               // 10565:   decode to VSHUF4I_H using decoder 129
                                             // 10565:  }
  230, 1, 5,                                 // 10570:  case 0xe6: {
  OPC_Decode, 152, 11, 129, 1,               // 10573:   decode to VSHUF4I_W using decoder 129
                                             // 10573:  }
  231, 1, 5,                                 // 10578:  case 0xe7: {
  OPC_Decode, 150, 11, 128, 1,               // 10581:   decode to VSHUF4I_D using decoder 128
                                             // 10581:  }
  241, 1, 5,                                 // 10586:  case 0xf1: {
  OPC_Decode, 228, 7, 128, 1,                // 10589:   decode to VBITSELI_B using decoder 128
                                             // 10589:  }
  244, 1, 5,                                 // 10594:  case 0xf4: {
  OPC_Decode, 193, 7, 129, 1,                // 10597:   decode to VANDI_B using decoder 129
                                             // 10597:  }
  245, 1, 5,                                 // 10602:  case 0xf5: {
  OPC_Decode, 191, 10, 129, 1,               // 10605:   decode to VORI_B using decoder 129
                                             // 10605:  }
  246, 1, 5,                                 // 10610:  case 0xf6: {
  OPC_Decode, 234, 12, 129, 1,               // 10613:   decode to VXORI_B using decoder 129
                                             // 10613:  }
  247, 1, 5,                                 // 10618:  case 0xf7: {
  OPC_Decode, 189, 10, 129, 1,               // 10621:   decode to VNORI_B using decoder 129
                                             // 10621:  }
  248, 1, 5,                                 // 10626:  case 0xf8: {
  OPC_Decode, 193, 9, 130, 1,                // 10629:   decode to VLDI using decoder 130
                                             // 10629:  }
  249, 1, 0,                                 // 10634:  case 0xf9: {
  OPC_Decode, 206, 10, 128, 1,               // 10637:   decode to VPERMI_W using decoder 128
                                             // 10637:  }
                                             // 10637:  } // switch Inst[25:18]
                                             // 10637: }
  29, 0,                                     // 10642: case 0x1d: {
  OPC_SwitchField, 18, 8,                    // 10644:  switch Inst[25:18] {
  0, 51,                                     // 10647:  case 0x0: {
  OPC_SwitchField, 15, 3,                    // 10649:   switch Inst[17:15] {
  0, 4,                                      // 10652:   case 0x0: {
  OPC_Decode, 205, 17, 64,                   // 10654:    decode to XVSEQ_B using decoder 64
                                             // 10654:   }
  1, 4,                                      // 10658:   case 0x1: {
  OPC_Decode, 207, 17, 64,                   // 10660:    decode to XVSEQ_H using decoder 64
                                             // 10660:   }
  2, 4,                                      // 10664:   case 0x2: {
  OPC_Decode, 208, 17, 64,                   // 10666:    decode to XVSEQ_W using decoder 64
                                             // 10666:   }
  3, 4,                                      // 10670:   case 0x3: {
  OPC_Decode, 206, 17, 64,                   // 10672:    decode to XVSEQ_D using decoder 64
                                             // 10672:   }
  4, 4,                                      // 10676:   case 0x4: {
  OPC_Decode, 239, 17, 64,                   // 10678:    decode to XVSLE_B using decoder 64
                                             // 10678:   }
  5, 4,                                      // 10682:   case 0x5: {
  OPC_Decode, 243, 17, 64,                   // 10684:    decode to XVSLE_H using decoder 64
                                             // 10684:   }
  6, 4,                                      // 10688:   case 0x6: {
  OPC_Decode, 245, 17, 64,                   // 10690:    decode to XVSLE_W using decoder 64
                                             // 10690:   }
  7, 0,                                      // 10694:   case 0x7: {
  OPC_Decode, 241, 17, 64,                   // 10696:    decode to XVSLE_D using decoder 64
                                             // 10696:   }
                                             // 10696:   } // switch Inst[17:15]
                                             // 10696:  }
  1, 51,                                     // 10700:  case 0x1: {
  OPC_SwitchField, 15, 3,                    // 10702:   switch Inst[17:15] {
  0, 4,                                      // 10705:   case 0x0: {
  OPC_Decode, 240, 17, 64,                   // 10707:    decode to XVSLE_BU using decoder 64
                                             // 10707:   }
  1, 4,                                      // 10711:   case 0x1: {
  OPC_Decode, 244, 17, 64,                   // 10713:    decode to XVSLE_HU using decoder 64
                                             // 10713:   }
  2, 4,                                      // 10717:   case 0x2: {
  OPC_Decode, 246, 17, 64,                   // 10719:    decode to XVSLE_WU using decoder 64
                                             // 10719:   }
  3, 4,                                      // 10723:   case 0x3: {
  OPC_Decode, 242, 17, 64,                   // 10725:    decode to XVSLE_DU using decoder 64
                                             // 10725:   }
  4, 4,                                      // 10729:   case 0x4: {
  OPC_Decode, 141, 18, 64,                   // 10731:    decode to XVSLT_B using decoder 64
                                             // 10731:   }
  5, 4,                                      // 10735:   case 0x5: {
  OPC_Decode, 145, 18, 64,                   // 10737:    decode to XVSLT_H using decoder 64
                                             // 10737:   }
  6, 4,                                      // 10741:   case 0x6: {
  OPC_Decode, 147, 18, 64,                   // 10743:    decode to XVSLT_W using decoder 64
                                             // 10743:   }
  7, 0,                                      // 10747:   case 0x7: {
  OPC_Decode, 143, 18, 64,                   // 10749:    decode to XVSLT_D using decoder 64
                                             // 10749:   }
                                             // 10749:   } // switch Inst[17:15]
                                             // 10749:  }
  2, 51,                                     // 10753:  case 0x2: {
  OPC_SwitchField, 15, 3,                    // 10755:   switch Inst[17:15] {
  0, 4,                                      // 10758:   case 0x0: {
  OPC_Decode, 142, 18, 64,                   // 10760:    decode to XVSLT_BU using decoder 64
                                             // 10760:   }
  1, 4,                                      // 10764:   case 0x1: {
  OPC_Decode, 146, 18, 64,                   // 10766:    decode to XVSLT_HU using decoder 64
                                             // 10766:   }
  2, 4,                                      // 10770:   case 0x2: {
  OPC_Decode, 148, 18, 64,                   // 10772:    decode to XVSLT_WU using decoder 64
                                             // 10772:   }
  3, 4,                                      // 10776:   case 0x3: {
  OPC_Decode, 144, 18, 64,                   // 10778:    decode to XVSLT_DU using decoder 64
                                             // 10778:   }
  4, 4,                                      // 10782:   case 0x4: {
  OPC_Decode, 135, 14, 64,                   // 10784:    decode to XVADD_B using decoder 64
                                             // 10784:   }
  5, 4,                                      // 10788:   case 0x5: {
  OPC_Decode, 137, 14, 64,                   // 10790:    decode to XVADD_H using decoder 64
                                             // 10790:   }
  6, 4,                                      // 10794:   case 0x6: {
  OPC_Decode, 139, 14, 64,                   // 10796:    decode to XVADD_W using decoder 64
                                             // 10796:   }
  7, 0,                                      // 10800:   case 0x7: {
  OPC_Decode, 136, 14, 64,                   // 10802:    decode to XVADD_D using decoder 64
                                             // 10802:   }
                                             // 10802:   } // switch Inst[17:15]
                                             // 10802:  }
  3, 27,                                     // 10806:  case 0x3: {
  OPC_SwitchField, 15, 3,                    // 10808:   switch Inst[17:15] {
  0, 4,                                      // 10811:   case 0x0: {
  OPC_Decode, 171, 19, 64,                   // 10813:    decode to XVSUB_B using decoder 64
                                             // 10813:   }
  1, 4,                                      // 10817:   case 0x1: {
  OPC_Decode, 173, 19, 64,                   // 10819:    decode to XVSUB_H using decoder 64
                                             // 10819:   }
  2, 4,                                      // 10823:   case 0x2: {
  OPC_Decode, 175, 19, 64,                   // 10825:    decode to XVSUB_W using decoder 64
                                             // 10825:   }
  3, 0,                                      // 10829:   case 0x3: {
  OPC_Decode, 172, 19, 64,                   // 10831:    decode to XVSUB_D using decoder 64
                                             // 10831:   }
                                             // 10831:   } // switch Inst[17:15]
                                             // 10831:  }
  7, 27,                                     // 10835:  case 0x7: {
  OPC_SwitchField, 15, 3,                    // 10837:   switch Inst[17:15] {
  4, 4,                                      // 10840:   case 0x4: {
  OPC_Decode, 242, 13, 64,                   // 10842:    decode to XVADDWEV_H_B using decoder 64
                                             // 10842:   }
  5, 4,                                      // 10846:   case 0x5: {
  OPC_Decode, 248, 13, 64,                   // 10848:    decode to XVADDWEV_W_H using decoder 64
                                             // 10848:   }
  6, 4,                                      // 10852:   case 0x6: {
  OPC_Decode, 239, 13, 64,                   // 10854:    decode to XVADDWEV_D_W using decoder 64
                                             // 10854:   }
  7, 0,                                      // 10858:   case 0x7: {
  OPC_Decode, 245, 13, 64,                   // 10860:    decode to XVADDWEV_Q_D using decoder 64
                                             // 10860:   }
                                             // 10860:   } // switch Inst[17:15]
                                             // 10860:  }
  8, 51,                                     // 10864:  case 0x8: {
  OPC_SwitchField, 15, 3,                    // 10866:   switch Inst[17:15] {
  0, 4,                                      // 10869:   case 0x0: {
  OPC_Decode, 157, 19, 64,                   // 10871:    decode to XVSUBWEV_H_B using decoder 64
                                             // 10871:   }
  1, 4,                                      // 10875:   case 0x1: {
  OPC_Decode, 161, 19, 64,                   // 10877:    decode to XVSUBWEV_W_H using decoder 64
                                             // 10877:   }
  2, 4,                                      // 10881:   case 0x2: {
  OPC_Decode, 155, 19, 64,                   // 10883:    decode to XVSUBWEV_D_W using decoder 64
                                             // 10883:   }
  3, 4,                                      // 10887:   case 0x3: {
  OPC_Decode, 159, 19, 64,                   // 10889:    decode to XVSUBWEV_Q_D using decoder 64
                                             // 10889:   }
  4, 4,                                      // 10893:   case 0x4: {
  OPC_Decode, 254, 13, 64,                   // 10895:    decode to XVADDWOD_H_B using decoder 64
                                             // 10895:   }
  5, 4,                                      // 10899:   case 0x5: {
  OPC_Decode, 132, 14, 64,                   // 10901:    decode to XVADDWOD_W_H using decoder 64
                                             // 10901:   }
  6, 4,                                      // 10905:   case 0x6: {
  OPC_Decode, 251, 13, 64,                   // 10907:    decode to XVADDWOD_D_W using decoder 64
                                             // 10907:   }
  7, 0,                                      // 10911:   case 0x7: {
  OPC_Decode, 129, 14, 64,                   // 10913:    decode to XVADDWOD_Q_D using decoder 64
                                             // 10913:   }
                                             // 10913:   } // switch Inst[17:15]
                                             // 10913:  }
  9, 27,                                     // 10917:  case 0x9: {
  OPC_SwitchField, 15, 3,                    // 10919:   switch Inst[17:15] {
  0, 4,                                      // 10922:   case 0x0: {
  OPC_Decode, 165, 19, 64,                   // 10924:    decode to XVSUBWOD_H_B using decoder 64
                                             // 10924:   }
  1, 4,                                      // 10928:   case 0x1: {
  OPC_Decode, 169, 19, 64,                   // 10930:    decode to XVSUBWOD_W_H using decoder 64
                                             // 10930:   }
  2, 4,                                      // 10934:   case 0x2: {
  OPC_Decode, 163, 19, 64,                   // 10936:    decode to XVSUBWOD_D_W using decoder 64
                                             // 10936:   }
  3, 0,                                      // 10940:   case 0x3: {
  OPC_Decode, 167, 19, 64,                   // 10942:    decode to XVSUBWOD_Q_D using decoder 64
                                             // 10942:   }
                                             // 10942:   } // switch Inst[17:15]
                                             // 10942:  }
  11, 27,                                    // 10946:  case 0xb: {
  OPC_SwitchField, 15, 3,                    // 10948:   switch Inst[17:15] {
  4, 4,                                      // 10951:   case 0x4: {
  OPC_Decode, 243, 13, 64,                   // 10953:    decode to XVADDWEV_H_BU using decoder 64
                                             // 10953:   }
  5, 4,                                      // 10957:   case 0x5: {
  OPC_Decode, 249, 13, 64,                   // 10959:    decode to XVADDWEV_W_HU using decoder 64
                                             // 10959:   }
  6, 4,                                      // 10963:   case 0x6: {
  OPC_Decode, 240, 13, 64,                   // 10965:    decode to XVADDWEV_D_WU using decoder 64
                                             // 10965:   }
  7, 0,                                      // 10969:   case 0x7: {
  OPC_Decode, 246, 13, 64,                   // 10971:    decode to XVADDWEV_Q_DU using decoder 64
                                             // 10971:   }
                                             // 10971:   } // switch Inst[17:15]
                                             // 10971:  }
  12, 51,                                    // 10975:  case 0xc: {
  OPC_SwitchField, 15, 3,                    // 10977:   switch Inst[17:15] {
  0, 4,                                      // 10980:   case 0x0: {
  OPC_Decode, 158, 19, 64,                   // 10982:    decode to XVSUBWEV_H_BU using decoder 64
                                             // 10982:   }
  1, 4,                                      // 10986:   case 0x1: {
  OPC_Decode, 162, 19, 64,                   // 10988:    decode to XVSUBWEV_W_HU using decoder 64
                                             // 10988:   }
  2, 4,                                      // 10992:   case 0x2: {
  OPC_Decode, 156, 19, 64,                   // 10994:    decode to XVSUBWEV_D_WU using decoder 64
                                             // 10994:   }
  3, 4,                                      // 10998:   case 0x3: {
  OPC_Decode, 160, 19, 64,                   // 11000:    decode to XVSUBWEV_Q_DU using decoder 64
                                             // 11000:   }
  4, 4,                                      // 11004:   case 0x4: {
  OPC_Decode, 255, 13, 64,                   // 11006:    decode to XVADDWOD_H_BU using decoder 64
                                             // 11006:   }
  5, 4,                                      // 11010:   case 0x5: {
  OPC_Decode, 133, 14, 64,                   // 11012:    decode to XVADDWOD_W_HU using decoder 64
                                             // 11012:   }
  6, 4,                                      // 11016:   case 0x6: {
  OPC_Decode, 252, 13, 64,                   // 11018:    decode to XVADDWOD_D_WU using decoder 64
                                             // 11018:   }
  7, 0,                                      // 11022:   case 0x7: {
  OPC_Decode, 130, 14, 64,                   // 11024:    decode to XVADDWOD_Q_DU using decoder 64
                                             // 11024:   }
                                             // 11024:   } // switch Inst[17:15]
                                             // 11024:  }
  13, 27,                                    // 11028:  case 0xd: {
  OPC_SwitchField, 15, 3,                    // 11030:   switch Inst[17:15] {
  0, 4,                                      // 11033:   case 0x0: {
  OPC_Decode, 166, 19, 64,                   // 11035:    decode to XVSUBWOD_H_BU using decoder 64
                                             // 11035:   }
  1, 4,                                      // 11039:   case 0x1: {
  OPC_Decode, 170, 19, 64,                   // 11041:    decode to XVSUBWOD_W_HU using decoder 64
                                             // 11041:   }
  2, 4,                                      // 11045:   case 0x2: {
  OPC_Decode, 164, 19, 64,                   // 11047:    decode to XVSUBWOD_D_WU using decoder 64
                                             // 11047:   }
  3, 0,                                      // 11051:   case 0x3: {
  OPC_Decode, 168, 19, 64,                   // 11053:    decode to XVSUBWOD_Q_DU using decoder 64
                                             // 11053:   }
                                             // 11053:   } // switch Inst[17:15]
                                             // 11053:  }
  15, 27,                                    // 11057:  case 0xf: {
  OPC_SwitchField, 15, 3,                    // 11059:   switch Inst[17:15] {
  4, 4,                                      // 11062:   case 0x4: {
  OPC_Decode, 244, 13, 64,                   // 11064:    decode to XVADDWEV_H_BU_B using decoder 64
                                             // 11064:   }
  5, 4,                                      // 11068:   case 0x5: {
  OPC_Decode, 250, 13, 64,                   // 11070:    decode to XVADDWEV_W_HU_H using decoder 64
                                             // 11070:   }
  6, 4,                                      // 11074:   case 0x6: {
  OPC_Decode, 241, 13, 64,                   // 11076:    decode to XVADDWEV_D_WU_W using decoder 64
                                             // 11076:   }
  7, 0,                                      // 11080:   case 0x7: {
  OPC_Decode, 247, 13, 64,                   // 11082:    decode to XVADDWEV_Q_DU_D using decoder 64
                                             // 11082:   }
                                             // 11082:   } // switch Inst[17:15]
                                             // 11082:  }
  16, 27,                                    // 11086:  case 0x10: {
  OPC_SwitchField, 15, 3,                    // 11088:   switch Inst[17:15] {
  0, 4,                                      // 11091:   case 0x0: {
  OPC_Decode, 128, 14, 64,                   // 11093:    decode to XVADDWOD_H_BU_B using decoder 64
                                             // 11093:   }
  1, 4,                                      // 11097:   case 0x1: {
  OPC_Decode, 134, 14, 64,                   // 11099:    decode to XVADDWOD_W_HU_H using decoder 64
                                             // 11099:   }
  2, 4,                                      // 11103:   case 0x2: {
  OPC_Decode, 253, 13, 64,                   // 11105:    decode to XVADDWOD_D_WU_W using decoder 64
                                             // 11105:   }
  3, 0,                                      // 11109:   case 0x3: {
  OPC_Decode, 131, 14, 64,                   // 11111:    decode to XVADDWOD_Q_DU_D using decoder 64
                                             // 11111:   }
                                             // 11111:   } // switch Inst[17:15]
                                             // 11111:  }
  17, 27,                                    // 11115:  case 0x11: {
  OPC_SwitchField, 15, 3,                    // 11117:   switch Inst[17:15] {
  4, 4,                                      // 11120:   case 0x4: {
  OPC_Decode, 185, 17, 64,                   // 11122:    decode to XVSADD_B using decoder 64
                                             // 11122:   }
  5, 4,                                      // 11126:   case 0x5: {
  OPC_Decode, 189, 17, 64,                   // 11128:    decode to XVSADD_H using decoder 64
                                             // 11128:   }
  6, 4,                                      // 11132:   case 0x6: {
  OPC_Decode, 191, 17, 64,                   // 11134:    decode to XVSADD_W using decoder 64
                                             // 11134:   }
  7, 0,                                      // 11138:   case 0x7: {
  OPC_Decode, 187, 17, 64,                   // 11140:    decode to XVSADD_D using decoder 64
                                             // 11140:   }
                                             // 11140:   } // switch Inst[17:15]
                                             // 11140:  }
  18, 51,                                    // 11144:  case 0x12: {
  OPC_SwitchField, 15, 3,                    // 11146:   switch Inst[17:15] {
  0, 4,                                      // 11149:   case 0x0: {
  OPC_Decode, 137, 19, 64,                   // 11151:    decode to XVSSUB_B using decoder 64
                                             // 11151:   }
  1, 4,                                      // 11155:   case 0x1: {
  OPC_Decode, 141, 19, 64,                   // 11157:    decode to XVSSUB_H using decoder 64
                                             // 11157:   }
  2, 4,                                      // 11161:   case 0x2: {
  OPC_Decode, 143, 19, 64,                   // 11163:    decode to XVSSUB_W using decoder 64
                                             // 11163:   }
  3, 4,                                      // 11167:   case 0x3: {
  OPC_Decode, 139, 19, 64,                   // 11169:    decode to XVSSUB_D using decoder 64
                                             // 11169:   }
  4, 4,                                      // 11173:   case 0x4: {
  OPC_Decode, 186, 17, 64,                   // 11175:    decode to XVSADD_BU using decoder 64
                                             // 11175:   }
  5, 4,                                      // 11179:   case 0x5: {
  OPC_Decode, 190, 17, 64,                   // 11181:    decode to XVSADD_HU using decoder 64
                                             // 11181:   }
  6, 4,                                      // 11185:   case 0x6: {
  OPC_Decode, 192, 17, 64,                   // 11187:    decode to XVSADD_WU using decoder 64
                                             // 11187:   }
  7, 0,                                      // 11191:   case 0x7: {
  OPC_Decode, 188, 17, 64,                   // 11193:    decode to XVSADD_DU using decoder 64
                                             // 11193:   }
                                             // 11193:   } // switch Inst[17:15]
                                             // 11193:  }
  19, 27,                                    // 11197:  case 0x13: {
  OPC_SwitchField, 15, 3,                    // 11199:   switch Inst[17:15] {
  0, 4,                                      // 11202:   case 0x0: {
  OPC_Decode, 138, 19, 64,                   // 11204:    decode to XVSSUB_BU using decoder 64
                                             // 11204:   }
  1, 4,                                      // 11208:   case 0x1: {
  OPC_Decode, 142, 19, 64,                   // 11210:    decode to XVSSUB_HU using decoder 64
                                             // 11210:   }
  2, 4,                                      // 11214:   case 0x2: {
  OPC_Decode, 144, 19, 64,                   // 11216:    decode to XVSSUB_WU using decoder 64
                                             // 11216:   }
  3, 0,                                      // 11220:   case 0x3: {
  OPC_Decode, 140, 19, 64,                   // 11222:    decode to XVSSUB_DU using decoder 64
                                             // 11222:   }
                                             // 11222:   } // switch Inst[17:15]
                                             // 11222:  }
  21, 51,                                    // 11226:  case 0x15: {
  OPC_SwitchField, 15, 3,                    // 11228:   switch Inst[17:15] {
  0, 4,                                      // 11231:   case 0x0: {
  OPC_Decode, 230, 15, 64,                   // 11233:    decode to XVHADDW_H_B using decoder 64
                                             // 11233:   }
  1, 4,                                      // 11237:   case 0x1: {
  OPC_Decode, 234, 15, 64,                   // 11239:    decode to XVHADDW_W_H using decoder 64
                                             // 11239:   }
  2, 4,                                      // 11243:   case 0x2: {
  OPC_Decode, 228, 15, 64,                   // 11245:    decode to XVHADDW_D_W using decoder 64
                                             // 11245:   }
  3, 4,                                      // 11249:   case 0x3: {
  OPC_Decode, 232, 15, 64,                   // 11251:    decode to XVHADDW_Q_D using decoder 64
                                             // 11251:   }
  4, 4,                                      // 11255:   case 0x4: {
  OPC_Decode, 239, 15, 64,                   // 11257:    decode to XVHSUBW_H_B using decoder 64
                                             // 11257:   }
  5, 4,                                      // 11261:   case 0x5: {
  OPC_Decode, 243, 15, 64,                   // 11263:    decode to XVHSUBW_W_H using decoder 64
                                             // 11263:   }
  6, 4,                                      // 11267:   case 0x6: {
  OPC_Decode, 237, 15, 64,                   // 11269:    decode to XVHSUBW_D_W using decoder 64
                                             // 11269:   }
  7, 0,                                      // 11273:   case 0x7: {
  OPC_Decode, 241, 15, 64,                   // 11275:    decode to XVHSUBW_Q_D using decoder 64
                                             // 11275:   }
                                             // 11275:   } // switch Inst[17:15]
                                             // 11275:  }
  22, 51,                                    // 11279:  case 0x16: {
  OPC_SwitchField, 15, 3,                    // 11281:   switch Inst[17:15] {
  0, 4,                                      // 11284:   case 0x0: {
  OPC_Decode, 229, 15, 64,                   // 11286:    decode to XVHADDW_HU_BU using decoder 64
                                             // 11286:   }
  1, 4,                                      // 11290:   case 0x1: {
  OPC_Decode, 233, 15, 64,                   // 11292:    decode to XVHADDW_WU_HU using decoder 64
                                             // 11292:   }
  2, 4,                                      // 11296:   case 0x2: {
  OPC_Decode, 227, 15, 64,                   // 11298:    decode to XVHADDW_DU_WU using decoder 64
                                             // 11298:   }
  3, 4,                                      // 11302:   case 0x3: {
  OPC_Decode, 231, 15, 64,                   // 11304:    decode to XVHADDW_QU_DU using decoder 64
                                             // 11304:   }
  4, 4,                                      // 11308:   case 0x4: {
  OPC_Decode, 238, 15, 64,                   // 11310:    decode to XVHSUBW_HU_BU using decoder 64
                                             // 11310:   }
  5, 4,                                      // 11314:   case 0x5: {
  OPC_Decode, 242, 15, 64,                   // 11316:    decode to XVHSUBW_WU_HU using decoder 64
                                             // 11316:   }
  6, 4,                                      // 11320:   case 0x6: {
  OPC_Decode, 236, 15, 64,                   // 11322:    decode to XVHSUBW_DU_WU using decoder 64
                                             // 11322:   }
  7, 0,                                      // 11326:   case 0x7: {
  OPC_Decode, 240, 15, 64,                   // 11328:    decode to XVHSUBW_QU_DU using decoder 64
                                             // 11328:   }
                                             // 11328:   } // switch Inst[17:15]
                                             // 11328:  }
  23, 27,                                    // 11332:  case 0x17: {
  OPC_SwitchField, 15, 3,                    // 11334:   switch Inst[17:15] {
  0, 4,                                      // 11337:   case 0x0: {
  OPC_Decode, 231, 13, 64,                   // 11339:    decode to XVADDA_B using decoder 64
                                             // 11339:   }
  1, 4,                                      // 11343:   case 0x1: {
  OPC_Decode, 233, 13, 64,                   // 11345:    decode to XVADDA_H using decoder 64
                                             // 11345:   }
  2, 4,                                      // 11349:   case 0x2: {
  OPC_Decode, 234, 13, 64,                   // 11351:    decode to XVADDA_W using decoder 64
                                             // 11351:   }
  3, 0,                                      // 11355:   case 0x3: {
  OPC_Decode, 232, 13, 64,                   // 11357:    decode to XVADDA_D using decoder 64
                                             // 11357:   }
                                             // 11357:   } // switch Inst[17:15]
                                             // 11357:  }
  24, 51,                                    // 11361:  case 0x18: {
  OPC_SwitchField, 15, 3,                    // 11363:   switch Inst[17:15] {
  0, 4,                                      // 11366:   case 0x0: {
  OPC_Decode, 223, 13, 64,                   // 11368:    decode to XVABSD_B using decoder 64
                                             // 11368:   }
  1, 4,                                      // 11372:   case 0x1: {
  OPC_Decode, 227, 13, 64,                   // 11374:    decode to XVABSD_H using decoder 64
                                             // 11374:   }
  2, 4,                                      // 11378:   case 0x2: {
  OPC_Decode, 229, 13, 64,                   // 11380:    decode to XVABSD_W using decoder 64
                                             // 11380:   }
  3, 4,                                      // 11384:   case 0x3: {
  OPC_Decode, 225, 13, 64,                   // 11386:    decode to XVABSD_D using decoder 64
                                             // 11386:   }
  4, 4,                                      // 11390:   case 0x4: {
  OPC_Decode, 224, 13, 64,                   // 11392:    decode to XVABSD_BU using decoder 64
                                             // 11392:   }
  5, 4,                                      // 11396:   case 0x5: {
  OPC_Decode, 228, 13, 64,                   // 11398:    decode to XVABSD_HU using decoder 64
                                             // 11398:   }
  6, 4,                                      // 11402:   case 0x6: {
  OPC_Decode, 230, 13, 64,                   // 11404:    decode to XVABSD_WU using decoder 64
                                             // 11404:   }
  7, 0,                                      // 11408:   case 0x7: {
  OPC_Decode, 226, 13, 64,                   // 11410:    decode to XVABSD_DU using decoder 64
                                             // 11410:   }
                                             // 11410:   } // switch Inst[17:15]
                                             // 11410:  }
  25, 51,                                    // 11414:  case 0x19: {
  OPC_SwitchField, 15, 3,                    // 11416:   switch Inst[17:15] {
  0, 4,                                      // 11419:   case 0x0: {
  OPC_Decode, 151, 14, 64,                   // 11421:    decode to XVAVG_B using decoder 64
                                             // 11421:   }
  1, 4,                                      // 11425:   case 0x1: {
  OPC_Decode, 155, 14, 64,                   // 11427:    decode to XVAVG_H using decoder 64
                                             // 11427:   }
  2, 4,                                      // 11431:   case 0x2: {
  OPC_Decode, 157, 14, 64,                   // 11433:    decode to XVAVG_W using decoder 64
                                             // 11433:   }
  3, 4,                                      // 11437:   case 0x3: {
  OPC_Decode, 153, 14, 64,                   // 11439:    decode to XVAVG_D using decoder 64
                                             // 11439:   }
  4, 4,                                      // 11443:   case 0x4: {
  OPC_Decode, 152, 14, 64,                   // 11445:    decode to XVAVG_BU using decoder 64
                                             // 11445:   }
  5, 4,                                      // 11449:   case 0x5: {
  OPC_Decode, 156, 14, 64,                   // 11451:    decode to XVAVG_HU using decoder 64
                                             // 11451:   }
  6, 4,                                      // 11455:   case 0x6: {
  OPC_Decode, 158, 14, 64,                   // 11457:    decode to XVAVG_WU using decoder 64
                                             // 11457:   }
  7, 0,                                      // 11461:   case 0x7: {
  OPC_Decode, 154, 14, 64,                   // 11463:    decode to XVAVG_DU using decoder 64
                                             // 11463:   }
                                             // 11463:   } // switch Inst[17:15]
                                             // 11463:  }
  26, 51,                                    // 11467:  case 0x1a: {
  OPC_SwitchField, 15, 3,                    // 11469:   switch Inst[17:15] {
  0, 4,                                      // 11472:   case 0x0: {
  OPC_Decode, 143, 14, 64,                   // 11474:    decode to XVAVGR_B using decoder 64
                                             // 11474:   }
  1, 4,                                      // 11478:   case 0x1: {
  OPC_Decode, 147, 14, 64,                   // 11480:    decode to XVAVGR_H using decoder 64
                                             // 11480:   }
  2, 4,                                      // 11484:   case 0x2: {
  OPC_Decode, 149, 14, 64,                   // 11486:    decode to XVAVGR_W using decoder 64
                                             // 11486:   }
  3, 4,                                      // 11490:   case 0x3: {
  OPC_Decode, 145, 14, 64,                   // 11492:    decode to XVAVGR_D using decoder 64
                                             // 11492:   }
  4, 4,                                      // 11496:   case 0x4: {
  OPC_Decode, 144, 14, 64,                   // 11498:    decode to XVAVGR_BU using decoder 64
                                             // 11498:   }
  5, 4,                                      // 11502:   case 0x5: {
  OPC_Decode, 148, 14, 64,                   // 11504:    decode to XVAVGR_HU using decoder 64
                                             // 11504:   }
  6, 4,                                      // 11508:   case 0x6: {
  OPC_Decode, 150, 14, 64,                   // 11510:    decode to XVAVGR_WU using decoder 64
                                             // 11510:   }
  7, 0,                                      // 11514:   case 0x7: {
  OPC_Decode, 146, 14, 64,                   // 11516:    decode to XVAVGR_DU using decoder 64
                                             // 11516:   }
                                             // 11516:   } // switch Inst[17:15]
                                             // 11516:  }
  28, 51,                                    // 11520:  case 0x1c: {
  OPC_SwitchField, 15, 3,                    // 11522:   switch Inst[17:15] {
  0, 4,                                      // 11525:   case 0x0: {
  OPC_Decode, 171, 16, 64,                   // 11527:    decode to XVMAX_B using decoder 64
                                             // 11527:   }
  1, 4,                                      // 11531:   case 0x1: {
  OPC_Decode, 175, 16, 64,                   // 11533:    decode to XVMAX_H using decoder 64
                                             // 11533:   }
  2, 4,                                      // 11537:   case 0x2: {
  OPC_Decode, 177, 16, 64,                   // 11539:    decode to XVMAX_W using decoder 64
                                             // 11539:   }
  3, 4,                                      // 11543:   case 0x3: {
  OPC_Decode, 173, 16, 64,                   // 11545:    decode to XVMAX_D using decoder 64
                                             // 11545:   }
  4, 4,                                      // 11549:   case 0x4: {
  OPC_Decode, 187, 16, 64,                   // 11551:    decode to XVMIN_B using decoder 64
                                             // 11551:   }
  5, 4,                                      // 11555:   case 0x5: {
  OPC_Decode, 191, 16, 64,                   // 11557:    decode to XVMIN_H using decoder 64
                                             // 11557:   }
  6, 4,                                      // 11561:   case 0x6: {
  OPC_Decode, 193, 16, 64,                   // 11563:    decode to XVMIN_W using decoder 64
                                             // 11563:   }
  7, 0,                                      // 11567:   case 0x7: {
  OPC_Decode, 189, 16, 64,                   // 11569:    decode to XVMIN_D using decoder 64
                                             // 11569:   }
                                             // 11569:   } // switch Inst[17:15]
                                             // 11569:  }
  29, 51,                                    // 11573:  case 0x1d: {
  OPC_SwitchField, 15, 3,                    // 11575:   switch Inst[17:15] {
  0, 4,                                      // 11578:   case 0x0: {
  OPC_Decode, 172, 16, 64,                   // 11580:    decode to XVMAX_BU using decoder 64
                                             // 11580:   }
  1, 4,                                      // 11584:   case 0x1: {
  OPC_Decode, 176, 16, 64,                   // 11586:    decode to XVMAX_HU using decoder 64
                                             // 11586:   }
  2, 4,                                      // 11590:   case 0x2: {
  OPC_Decode, 178, 16, 64,                   // 11592:    decode to XVMAX_WU using decoder 64
                                             // 11592:   }
  3, 4,                                      // 11596:   case 0x3: {
  OPC_Decode, 174, 16, 64,                   // 11598:    decode to XVMAX_DU using decoder 64
                                             // 11598:   }
  4, 4,                                      // 11602:   case 0x4: {
  OPC_Decode, 188, 16, 64,                   // 11604:    decode to XVMIN_BU using decoder 64
                                             // 11604:   }
  5, 4,                                      // 11608:   case 0x5: {
  OPC_Decode, 192, 16, 64,                   // 11610:    decode to XVMIN_HU using decoder 64
                                             // 11610:   }
  6, 4,                                      // 11614:   case 0x6: {
  OPC_Decode, 194, 16, 64,                   // 11616:    decode to XVMIN_WU using decoder 64
                                             // 11616:   }
  7, 0,                                      // 11620:   case 0x7: {
  OPC_Decode, 190, 16, 64,                   // 11622:    decode to XVMIN_DU using decoder 64
                                             // 11622:   }
                                             // 11622:   } // switch Inst[17:15]
                                             // 11622:  }
  33, 51,                                    // 11626:  case 0x21: {
  OPC_SwitchField, 15, 3,                    // 11628:   switch Inst[17:15] {
  0, 4,                                      // 11631:   case 0x0: {
  OPC_Decode, 245, 16, 64,                   // 11633:    decode to XVMUL_B using decoder 64
                                             // 11633:   }
  1, 4,                                      // 11637:   case 0x1: {
  OPC_Decode, 247, 16, 64,                   // 11639:    decode to XVMUL_H using decoder 64
                                             // 11639:   }
  2, 4,                                      // 11643:   case 0x2: {
  OPC_Decode, 248, 16, 64,                   // 11645:    decode to XVMUL_W using decoder 64
                                             // 11645:   }
  3, 4,                                      // 11649:   case 0x3: {
  OPC_Decode, 246, 16, 64,                   // 11651:    decode to XVMUL_D using decoder 64
                                             // 11651:   }
  4, 4,                                      // 11655:   case 0x4: {
  OPC_Decode, 213, 16, 64,                   // 11657:    decode to XVMUH_B using decoder 64
                                             // 11657:   }
  5, 4,                                      // 11661:   case 0x5: {
  OPC_Decode, 217, 16, 64,                   // 11663:    decode to XVMUH_H using decoder 64
                                             // 11663:   }
  6, 4,                                      // 11667:   case 0x6: {
  OPC_Decode, 219, 16, 64,                   // 11669:    decode to XVMUH_W using decoder 64
                                             // 11669:   }
  7, 0,                                      // 11673:   case 0x7: {
  OPC_Decode, 215, 16, 64,                   // 11675:    decode to XVMUH_D using decoder 64
                                             // 11675:   }
                                             // 11675:   } // switch Inst[17:15]
                                             // 11675:  }
  34, 27,                                    // 11679:  case 0x22: {
  OPC_SwitchField, 15, 3,                    // 11681:   switch Inst[17:15] {
  0, 4,                                      // 11684:   case 0x0: {
  OPC_Decode, 214, 16, 64,                   // 11686:    decode to XVMUH_BU using decoder 64
                                             // 11686:   }
  1, 4,                                      // 11690:   case 0x1: {
  OPC_Decode, 218, 16, 64,                   // 11692:    decode to XVMUH_HU using decoder 64
                                             // 11692:   }
  2, 4,                                      // 11696:   case 0x2: {
  OPC_Decode, 220, 16, 64,                   // 11698:    decode to XVMUH_WU using decoder 64
                                             // 11698:   }
  3, 0,                                      // 11702:   case 0x3: {
  OPC_Decode, 216, 16, 64,                   // 11704:    decode to XVMUH_DU using decoder 64
                                             // 11704:   }
                                             // 11704:   } // switch Inst[17:15]
                                             // 11704:  }
  36, 51,                                    // 11708:  case 0x24: {
  OPC_SwitchField, 15, 3,                    // 11710:   switch Inst[17:15] {
  0, 4,                                      // 11713:   case 0x0: {
  OPC_Decode, 224, 16, 64,                   // 11715:    decode to XVMULWEV_H_B using decoder 64
                                             // 11715:   }
  1, 4,                                      // 11719:   case 0x1: {
  OPC_Decode, 230, 16, 64,                   // 11721:    decode to XVMULWEV_W_H using decoder 64
                                             // 11721:   }
  2, 4,                                      // 11725:   case 0x2: {
  OPC_Decode, 221, 16, 64,                   // 11727:    decode to XVMULWEV_D_W using decoder 64
                                             // 11727:   }
  3, 4,                                      // 11731:   case 0x3: {
  OPC_Decode, 227, 16, 64,                   // 11733:    decode to XVMULWEV_Q_D using decoder 64
                                             // 11733:   }
  4, 4,                                      // 11737:   case 0x4: {
  OPC_Decode, 236, 16, 64,                   // 11739:    decode to XVMULWOD_H_B using decoder 64
                                             // 11739:   }
  5, 4,                                      // 11743:   case 0x5: {
  OPC_Decode, 242, 16, 64,                   // 11745:    decode to XVMULWOD_W_H using decoder 64
                                             // 11745:   }
  6, 4,                                      // 11749:   case 0x6: {
  OPC_Decode, 233, 16, 64,                   // 11751:    decode to XVMULWOD_D_W using decoder 64
                                             // 11751:   }
  7, 0,                                      // 11755:   case 0x7: {
  OPC_Decode, 239, 16, 64,                   // 11757:    decode to XVMULWOD_Q_D using decoder 64
                                             // 11757:   }
                                             // 11757:   } // switch Inst[17:15]
                                             // 11757:  }
  38, 51,                                    // 11761:  case 0x26: {
  OPC_SwitchField, 15, 3,                    // 11763:   switch Inst[17:15] {
  0, 4,                                      // 11766:   case 0x0: {
  OPC_Decode, 225, 16, 64,                   // 11768:    decode to XVMULWEV_H_BU using decoder 64
                                             // 11768:   }
  1, 4,                                      // 11772:   case 0x1: {
  OPC_Decode, 231, 16, 64,                   // 11774:    decode to XVMULWEV_W_HU using decoder 64
                                             // 11774:   }
  2, 4,                                      // 11778:   case 0x2: {
  OPC_Decode, 222, 16, 64,                   // 11780:    decode to XVMULWEV_D_WU using decoder 64
                                             // 11780:   }
  3, 4,                                      // 11784:   case 0x3: {
  OPC_Decode, 228, 16, 64,                   // 11786:    decode to XVMULWEV_Q_DU using decoder 64
                                             // 11786:   }
  4, 4,                                      // 11790:   case 0x4: {
  OPC_Decode, 237, 16, 64,                   // 11792:    decode to XVMULWOD_H_BU using decoder 64
                                             // 11792:   }
  5, 4,                                      // 11796:   case 0x5: {
  OPC_Decode, 243, 16, 64,                   // 11798:    decode to XVMULWOD_W_HU using decoder 64
                                             // 11798:   }
  6, 4,                                      // 11802:   case 0x6: {
  OPC_Decode, 234, 16, 64,                   // 11804:    decode to XVMULWOD_D_WU using decoder 64
                                             // 11804:   }
  7, 0,                                      // 11808:   case 0x7: {
  OPC_Decode, 240, 16, 64,                   // 11810:    decode to XVMULWOD_Q_DU using decoder 64
                                             // 11810:   }
                                             // 11810:   } // switch Inst[17:15]
                                             // 11810:  }
  40, 51,                                    // 11814:  case 0x28: {
  OPC_SwitchField, 15, 3,                    // 11816:   switch Inst[17:15] {
  0, 4,                                      // 11819:   case 0x0: {
  OPC_Decode, 226, 16, 64,                   // 11821:    decode to XVMULWEV_H_BU_B using decoder 64
                                             // 11821:   }
  1, 4,                                      // 11825:   case 0x1: {
  OPC_Decode, 232, 16, 64,                   // 11827:    decode to XVMULWEV_W_HU_H using decoder 64
                                             // 11827:   }
  2, 4,                                      // 11831:   case 0x2: {
  OPC_Decode, 223, 16, 64,                   // 11833:    decode to XVMULWEV_D_WU_W using decoder 64
                                             // 11833:   }
  3, 4,                                      // 11837:   case 0x3: {
  OPC_Decode, 229, 16, 64,                   // 11839:    decode to XVMULWEV_Q_DU_D using decoder 64
                                             // 11839:   }
  4, 4,                                      // 11843:   case 0x4: {
  OPC_Decode, 238, 16, 64,                   // 11845:    decode to XVMULWOD_H_BU_B using decoder 64
                                             // 11845:   }
  5, 4,                                      // 11849:   case 0x5: {
  OPC_Decode, 244, 16, 64,                   // 11851:    decode to XVMULWOD_W_HU_H using decoder 64
                                             // 11851:   }
  6, 4,                                      // 11855:   case 0x6: {
  OPC_Decode, 235, 16, 64,                   // 11857:    decode to XVMULWOD_D_WU_W using decoder 64
                                             // 11857:   }
  7, 0,                                      // 11861:   case 0x7: {
  OPC_Decode, 241, 16, 64,                   // 11863:    decode to XVMULWOD_Q_DU_D using decoder 64
                                             // 11863:   }
                                             // 11863:   } // switch Inst[17:15]
                                             // 11863:  }
  42, 59,                                    // 11867:  case 0x2a: {
  OPC_SwitchField, 15, 3,                    // 11869:   switch Inst[17:15] {
  0, 5,                                      // 11872:   case 0x0: {
  OPC_Decode, 159, 16, 131, 1,               // 11874:    decode to XVMADD_B using decoder 131
                                             // 11874:   }
  1, 5,                                      // 11879:   case 0x1: {
  OPC_Decode, 161, 16, 131, 1,               // 11881:    decode to XVMADD_H using decoder 131
                                             // 11881:   }
  2, 5,                                      // 11886:   case 0x2: {
  OPC_Decode, 162, 16, 131, 1,               // 11888:    decode to XVMADD_W using decoder 131
                                             // 11888:   }
  3, 5,                                      // 11893:   case 0x3: {
  OPC_Decode, 160, 16, 131, 1,               // 11895:    decode to XVMADD_D using decoder 131
                                             // 11895:   }
  4, 5,                                      // 11900:   case 0x4: {
  OPC_Decode, 209, 16, 131, 1,               // 11902:    decode to XVMSUB_B using decoder 131
                                             // 11902:   }
  5, 5,                                      // 11907:   case 0x5: {
  OPC_Decode, 211, 16, 131, 1,               // 11909:    decode to XVMSUB_H using decoder 131
                                             // 11909:   }
  6, 5,                                      // 11914:   case 0x6: {
  OPC_Decode, 212, 16, 131, 1,               // 11916:    decode to XVMSUB_W using decoder 131
                                             // 11916:   }
  7, 0,                                      // 11921:   case 0x7: {
  OPC_Decode, 210, 16, 131, 1,               // 11923:    decode to XVMSUB_D using decoder 131
                                             // 11923:   }
                                             // 11923:   } // switch Inst[17:15]
                                             // 11923:  }
  43, 59,                                    // 11928:  case 0x2b: {
  OPC_SwitchField, 15, 3,                    // 11930:   switch Inst[17:15] {
  0, 5,                                      // 11933:   case 0x0: {
  OPC_Decode, 138, 16, 131, 1,               // 11935:    decode to XVMADDWEV_H_B using decoder 131
                                             // 11935:   }
  1, 5,                                      // 11940:   case 0x1: {
  OPC_Decode, 144, 16, 131, 1,               // 11942:    decode to XVMADDWEV_W_H using decoder 131
                                             // 11942:   }
  2, 5,                                      // 11947:   case 0x2: {
  OPC_Decode, 135, 16, 131, 1,               // 11949:    decode to XVMADDWEV_D_W using decoder 131
                                             // 11949:   }
  3, 5,                                      // 11954:   case 0x3: {
  OPC_Decode, 141, 16, 131, 1,               // 11956:    decode to XVMADDWEV_Q_D using decoder 131
                                             // 11956:   }
  4, 5,                                      // 11961:   case 0x4: {
  OPC_Decode, 150, 16, 131, 1,               // 11963:    decode to XVMADDWOD_H_B using decoder 131
                                             // 11963:   }
  5, 5,                                      // 11968:   case 0x5: {
  OPC_Decode, 156, 16, 131, 1,               // 11970:    decode to XVMADDWOD_W_H using decoder 131
                                             // 11970:   }
  6, 5,                                      // 11975:   case 0x6: {
  OPC_Decode, 147, 16, 131, 1,               // 11977:    decode to XVMADDWOD_D_W using decoder 131
                                             // 11977:   }
  7, 0,                                      // 11982:   case 0x7: {
  OPC_Decode, 153, 16, 131, 1,               // 11984:    decode to XVMADDWOD_Q_D using decoder 131
                                             // 11984:   }
                                             // 11984:   } // switch Inst[17:15]
                                             // 11984:  }
  45, 59,                                    // 11989:  case 0x2d: {
  OPC_SwitchField, 15, 3,                    // 11991:   switch Inst[17:15] {
  0, 5,                                      // 11994:   case 0x0: {
  OPC_Decode, 139, 16, 131, 1,               // 11996:    decode to XVMADDWEV_H_BU using decoder 131
                                             // 11996:   }
  1, 5,                                      // 12001:   case 0x1: {
  OPC_Decode, 145, 16, 131, 1,               // 12003:    decode to XVMADDWEV_W_HU using decoder 131
                                             // 12003:   }
  2, 5,                                      // 12008:   case 0x2: {
  OPC_Decode, 136, 16, 131, 1,               // 12010:    decode to XVMADDWEV_D_WU using decoder 131
                                             // 12010:   }
  3, 5,                                      // 12015:   case 0x3: {
  OPC_Decode, 142, 16, 131, 1,               // 12017:    decode to XVMADDWEV_Q_DU using decoder 131
                                             // 12017:   }
  4, 5,                                      // 12022:   case 0x4: {
  OPC_Decode, 151, 16, 131, 1,               // 12024:    decode to XVMADDWOD_H_BU using decoder 131
                                             // 12024:   }
  5, 5,                                      // 12029:   case 0x5: {
  OPC_Decode, 157, 16, 131, 1,               // 12031:    decode to XVMADDWOD_W_HU using decoder 131
                                             // 12031:   }
  6, 5,                                      // 12036:   case 0x6: {
  OPC_Decode, 148, 16, 131, 1,               // 12038:    decode to XVMADDWOD_D_WU using decoder 131
                                             // 12038:   }
  7, 0,                                      // 12043:   case 0x7: {
  OPC_Decode, 154, 16, 131, 1,               // 12045:    decode to XVMADDWOD_Q_DU using decoder 131
                                             // 12045:   }
                                             // 12045:   } // switch Inst[17:15]
                                             // 12045:  }
  47, 59,                                    // 12050:  case 0x2f: {
  OPC_SwitchField, 15, 3,                    // 12052:   switch Inst[17:15] {
  0, 5,                                      // 12055:   case 0x0: {
  OPC_Decode, 140, 16, 131, 1,               // 12057:    decode to XVMADDWEV_H_BU_B using decoder 131
                                             // 12057:   }
  1, 5,                                      // 12062:   case 0x1: {
  OPC_Decode, 146, 16, 131, 1,               // 12064:    decode to XVMADDWEV_W_HU_H using decoder 131
                                             // 12064:   }
  2, 5,                                      // 12069:   case 0x2: {
  OPC_Decode, 137, 16, 131, 1,               // 12071:    decode to XVMADDWEV_D_WU_W using decoder 131
                                             // 12071:   }
  3, 5,                                      // 12076:   case 0x3: {
  OPC_Decode, 143, 16, 131, 1,               // 12078:    decode to XVMADDWEV_Q_DU_D using decoder 131
                                             // 12078:   }
  4, 5,                                      // 12083:   case 0x4: {
  OPC_Decode, 152, 16, 131, 1,               // 12085:    decode to XVMADDWOD_H_BU_B using decoder 131
                                             // 12085:   }
  5, 5,                                      // 12090:   case 0x5: {
  OPC_Decode, 158, 16, 131, 1,               // 12092:    decode to XVMADDWOD_W_HU_H using decoder 131
                                             // 12092:   }
  6, 5,                                      // 12097:   case 0x6: {
  OPC_Decode, 149, 16, 131, 1,               // 12099:    decode to XVMADDWOD_D_WU_W using decoder 131
                                             // 12099:   }
  7, 0,                                      // 12104:   case 0x7: {
  OPC_Decode, 155, 16, 131, 1,               // 12106:    decode to XVMADDWOD_Q_DU_D using decoder 131
                                             // 12106:   }
                                             // 12106:   } // switch Inst[17:15]
                                             // 12106:  }
  56, 51,                                    // 12111:  case 0x38: {
  OPC_SwitchField, 15, 3,                    // 12113:   switch Inst[17:15] {
  0, 4,                                      // 12116:   case 0x0: {
  OPC_Decode, 195, 14, 64,                   // 12118:    decode to XVDIV_B using decoder 64
                                             // 12118:   }
  1, 4,                                      // 12122:   case 0x1: {
  OPC_Decode, 199, 14, 64,                   // 12124:    decode to XVDIV_H using decoder 64
                                             // 12124:   }
  2, 4,                                      // 12128:   case 0x2: {
  OPC_Decode, 201, 14, 64,                   // 12130:    decode to XVDIV_W using decoder 64
                                             // 12130:   }
  3, 4,                                      // 12134:   case 0x3: {
  OPC_Decode, 197, 14, 64,                   // 12136:    decode to XVDIV_D using decoder 64
                                             // 12136:   }
  4, 4,                                      // 12140:   case 0x4: {
  OPC_Decode, 195, 16, 64,                   // 12142:    decode to XVMOD_B using decoder 64
                                             // 12142:   }
  5, 4,                                      // 12146:   case 0x5: {
  OPC_Decode, 199, 16, 64,                   // 12148:    decode to XVMOD_H using decoder 64
                                             // 12148:   }
  6, 4,                                      // 12152:   case 0x6: {
  OPC_Decode, 201, 16, 64,                   // 12154:    decode to XVMOD_W using decoder 64
                                             // 12154:   }
  7, 0,                                      // 12158:   case 0x7: {
  OPC_Decode, 197, 16, 64,                   // 12160:    decode to XVMOD_D using decoder 64
                                             // 12160:   }
                                             // 12160:   } // switch Inst[17:15]
                                             // 12160:  }
  57, 51,                                    // 12164:  case 0x39: {
  OPC_SwitchField, 15, 3,                    // 12166:   switch Inst[17:15] {
  0, 4,                                      // 12169:   case 0x0: {
  OPC_Decode, 196, 14, 64,                   // 12171:    decode to XVDIV_BU using decoder 64
                                             // 12171:   }
  1, 4,                                      // 12175:   case 0x1: {
  OPC_Decode, 200, 14, 64,                   // 12177:    decode to XVDIV_HU using decoder 64
                                             // 12177:   }
  2, 4,                                      // 12181:   case 0x2: {
  OPC_Decode, 202, 14, 64,                   // 12183:    decode to XVDIV_WU using decoder 64
                                             // 12183:   }
  3, 4,                                      // 12187:   case 0x3: {
  OPC_Decode, 198, 14, 64,                   // 12189:    decode to XVDIV_DU using decoder 64
                                             // 12189:   }
  4, 4,                                      // 12193:   case 0x4: {
  OPC_Decode, 196, 16, 64,                   // 12195:    decode to XVMOD_BU using decoder 64
                                             // 12195:   }
  5, 4,                                      // 12199:   case 0x5: {
  OPC_Decode, 200, 16, 64,                   // 12201:    decode to XVMOD_HU using decoder 64
                                             // 12201:   }
  6, 4,                                      // 12205:   case 0x6: {
  OPC_Decode, 202, 16, 64,                   // 12207:    decode to XVMOD_WU using decoder 64
                                             // 12207:   }
  7, 0,                                      // 12211:   case 0x7: {
  OPC_Decode, 198, 16, 64,                   // 12213:    decode to XVMOD_DU using decoder 64
                                             // 12213:   }
                                             // 12213:   } // switch Inst[17:15]
                                             // 12213:  }
  58, 51,                                    // 12217:  case 0x3a: {
  OPC_SwitchField, 15, 3,                    // 12219:   switch Inst[17:15] {
  0, 4,                                      // 12222:   case 0x0: {
  OPC_Decode, 129, 18, 64,                   // 12224:    decode to XVSLL_B using decoder 64
                                             // 12224:   }
  1, 4,                                      // 12228:   case 0x1: {
  OPC_Decode, 131, 18, 64,                   // 12230:    decode to XVSLL_H using decoder 64
                                             // 12230:   }
  2, 4,                                      // 12234:   case 0x2: {
  OPC_Decode, 132, 18, 64,                   // 12236:    decode to XVSLL_W using decoder 64
                                             // 12236:   }
  3, 4,                                      // 12240:   case 0x3: {
  OPC_Decode, 130, 18, 64,                   // 12242:    decode to XVSLL_D using decoder 64
                                             // 12242:   }
  4, 4,                                      // 12246:   case 0x4: {
  OPC_Decode, 205, 18, 64,                   // 12248:    decode to XVSRL_B using decoder 64
                                             // 12248:   }
  5, 4,                                      // 12252:   case 0x5: {
  OPC_Decode, 207, 18, 64,                   // 12254:    decode to XVSRL_H using decoder 64
                                             // 12254:   }
  6, 4,                                      // 12258:   case 0x6: {
  OPC_Decode, 208, 18, 64,                   // 12260:    decode to XVSRL_W using decoder 64
                                             // 12260:   }
  7, 0,                                      // 12264:   case 0x7: {
  OPC_Decode, 206, 18, 64,                   // 12266:    decode to XVSRL_D using decoder 64
                                             // 12266:   }
                                             // 12266:   } // switch Inst[17:15]
                                             // 12266:  }
  59, 51,                                    // 12270:  case 0x3b: {
  OPC_SwitchField, 15, 3,                    // 12272:   switch Inst[17:15] {
  0, 4,                                      // 12275:   case 0x0: {
  OPC_Decode, 175, 18, 64,                   // 12277:    decode to XVSRA_B using decoder 64
                                             // 12277:   }
  1, 4,                                      // 12281:   case 0x1: {
  OPC_Decode, 177, 18, 64,                   // 12283:    decode to XVSRA_H using decoder 64
                                             // 12283:   }
  2, 4,                                      // 12287:   case 0x2: {
  OPC_Decode, 178, 18, 64,                   // 12289:    decode to XVSRA_W using decoder 64
                                             // 12289:   }
  3, 4,                                      // 12293:   case 0x3: {
  OPC_Decode, 176, 18, 64,                   // 12295:    decode to XVSRA_D using decoder 64
                                             // 12295:   }
  4, 4,                                      // 12299:   case 0x4: {
  OPC_Decode, 181, 17, 64,                   // 12301:    decode to XVROTR_B using decoder 64
                                             // 12301:   }
  5, 4,                                      // 12305:   case 0x5: {
  OPC_Decode, 183, 17, 64,                   // 12307:    decode to XVROTR_H using decoder 64
                                             // 12307:   }
  6, 4,                                      // 12311:   case 0x6: {
  OPC_Decode, 184, 17, 64,                   // 12313:    decode to XVROTR_W using decoder 64
                                             // 12313:   }
  7, 0,                                      // 12317:   case 0x7: {
  OPC_Decode, 182, 17, 64,                   // 12319:    decode to XVROTR_D using decoder 64
                                             // 12319:   }
                                             // 12319:   } // switch Inst[17:15]
                                             // 12319:  }
  60, 51,                                    // 12323:  case 0x3c: {
  OPC_SwitchField, 15, 3,                    // 12325:   switch Inst[17:15] {
  0, 4,                                      // 12328:   case 0x0: {
  OPC_Decode, 201, 18, 64,                   // 12330:    decode to XVSRLR_B using decoder 64
                                             // 12330:   }
  1, 4,                                      // 12334:   case 0x1: {
  OPC_Decode, 203, 18, 64,                   // 12336:    decode to XVSRLR_H using decoder 64
                                             // 12336:   }
  2, 4,                                      // 12340:   case 0x2: {
  OPC_Decode, 204, 18, 64,                   // 12342:    decode to XVSRLR_W using decoder 64
                                             // 12342:   }
  3, 4,                                      // 12346:   case 0x3: {
  OPC_Decode, 202, 18, 64,                   // 12348:    decode to XVSRLR_D using decoder 64
                                             // 12348:   }
  4, 4,                                      // 12352:   case 0x4: {
  OPC_Decode, 171, 18, 64,                   // 12354:    decode to XVSRAR_B using decoder 64
                                             // 12354:   }
  5, 4,                                      // 12358:   case 0x5: {
  OPC_Decode, 173, 18, 64,                   // 12360:    decode to XVSRAR_H using decoder 64
                                             // 12360:   }
  6, 4,                                      // 12364:   case 0x6: {
  OPC_Decode, 174, 18, 64,                   // 12366:    decode to XVSRAR_W using decoder 64
                                             // 12366:   }
  7, 0,                                      // 12370:   case 0x7: {
  OPC_Decode, 172, 18, 64,                   // 12372:    decode to XVSRAR_D using decoder 64
                                             // 12372:   }
                                             // 12372:   } // switch Inst[17:15]
                                             // 12372:  }
  61, 39,                                    // 12376:  case 0x3d: {
  OPC_SwitchField, 15, 3,                    // 12378:   switch Inst[17:15] {
  1, 4,                                      // 12381:   case 0x1: {
  OPC_Decode, 187, 18, 64,                   // 12383:    decode to XVSRLN_B_H using decoder 64
                                             // 12383:   }
  2, 4,                                      // 12387:   case 0x2: {
  OPC_Decode, 188, 18, 64,                   // 12389:    decode to XVSRLN_H_W using decoder 64
                                             // 12389:   }
  3, 4,                                      // 12393:   case 0x3: {
  OPC_Decode, 189, 18, 64,                   // 12395:    decode to XVSRLN_W_D using decoder 64
                                             // 12395:   }
  5, 4,                                      // 12399:   case 0x5: {
  OPC_Decode, 157, 18, 64,                   // 12401:    decode to XVSRAN_B_H using decoder 64
                                             // 12401:   }
  6, 4,                                      // 12405:   case 0x6: {
  OPC_Decode, 158, 18, 64,                   // 12407:    decode to XVSRAN_H_W using decoder 64
                                             // 12407:   }
  7, 0,                                      // 12411:   case 0x7: {
  OPC_Decode, 159, 18, 64,                   // 12413:    decode to XVSRAN_W_D using decoder 64
                                             // 12413:   }
                                             // 12413:   } // switch Inst[17:15]
                                             // 12413:  }
  62, 39,                                    // 12417:  case 0x3e: {
  OPC_SwitchField, 15, 3,                    // 12419:   switch Inst[17:15] {
  1, 4,                                      // 12422:   case 0x1: {
  OPC_Decode, 198, 18, 64,                   // 12424:    decode to XVSRLRN_B_H using decoder 64
                                             // 12424:   }
  2, 4,                                      // 12428:   case 0x2: {
  OPC_Decode, 199, 18, 64,                   // 12430:    decode to XVSRLRN_H_W using decoder 64
                                             // 12430:   }
  3, 4,                                      // 12434:   case 0x3: {
  OPC_Decode, 200, 18, 64,                   // 12436:    decode to XVSRLRN_W_D using decoder 64
                                             // 12436:   }
  5, 4,                                      // 12440:   case 0x5: {
  OPC_Decode, 168, 18, 64,                   // 12442:    decode to XVSRARN_B_H using decoder 64
                                             // 12442:   }
  6, 4,                                      // 12446:   case 0x6: {
  OPC_Decode, 169, 18, 64,                   // 12448:    decode to XVSRARN_H_W using decoder 64
                                             // 12448:   }
  7, 0,                                      // 12452:   case 0x7: {
  OPC_Decode, 170, 18, 64,                   // 12454:    decode to XVSRARN_W_D using decoder 64
                                             // 12454:   }
                                             // 12454:   } // switch Inst[17:15]
                                             // 12454:  }
  63, 39,                                    // 12458:  case 0x3f: {
  OPC_SwitchField, 15, 3,                    // 12460:   switch Inst[17:15] {
  1, 4,                                      // 12463:   case 0x1: {
  OPC_Decode, 246, 18, 64,                   // 12465:    decode to XVSSRLN_B_H using decoder 64
                                             // 12465:   }
  2, 4,                                      // 12469:   case 0x2: {
  OPC_Decode, 248, 18, 64,                   // 12471:    decode to XVSSRLN_H_W using decoder 64
                                             // 12471:   }
  3, 4,                                      // 12475:   case 0x3: {
  OPC_Decode, 250, 18, 64,                   // 12477:    decode to XVSSRLN_W_D using decoder 64
                                             // 12477:   }
  5, 4,                                      // 12481:   case 0x5: {
  OPC_Decode, 218, 18, 64,                   // 12483:    decode to XVSSRAN_B_H using decoder 64
                                             // 12483:   }
  6, 4,                                      // 12487:   case 0x6: {
  OPC_Decode, 220, 18, 64,                   // 12489:    decode to XVSSRAN_H_W using decoder 64
                                             // 12489:   }
  7, 0,                                      // 12493:   case 0x7: {
  OPC_Decode, 222, 18, 64,                   // 12495:    decode to XVSSRAN_W_D using decoder 64
                                             // 12495:   }
                                             // 12495:   } // switch Inst[17:15]
                                             // 12495:  }
  64, 39,                                    // 12499:  case 0x40: {
  OPC_SwitchField, 15, 3,                    // 12501:   switch Inst[17:15] {
  1, 4,                                      // 12504:   case 0x1: {
  OPC_Decode, 132, 19, 64,                   // 12506:    decode to XVSSRLRN_B_H using decoder 64
                                             // 12506:   }
  2, 4,                                      // 12510:   case 0x2: {
  OPC_Decode, 134, 19, 64,                   // 12512:    decode to XVSSRLRN_H_W using decoder 64
                                             // 12512:   }
  3, 4,                                      // 12516:   case 0x3: {
  OPC_Decode, 136, 19, 64,                   // 12518:    decode to XVSSRLRN_W_D using decoder 64
                                             // 12518:   }
  5, 4,                                      // 12522:   case 0x5: {
  OPC_Decode, 232, 18, 64,                   // 12524:    decode to XVSSRARN_B_H using decoder 64
                                             // 12524:   }
  6, 4,                                      // 12528:   case 0x6: {
  OPC_Decode, 234, 18, 64,                   // 12530:    decode to XVSSRARN_H_W using decoder 64
                                             // 12530:   }
  7, 0,                                      // 12534:   case 0x7: {
  OPC_Decode, 236, 18, 64,                   // 12536:    decode to XVSSRARN_W_D using decoder 64
                                             // 12536:   }
                                             // 12536:   } // switch Inst[17:15]
                                             // 12536:  }
  65, 39,                                    // 12540:  case 0x41: {
  OPC_SwitchField, 15, 3,                    // 12542:   switch Inst[17:15] {
  1, 4,                                      // 12545:   case 0x1: {
  OPC_Decode, 245, 18, 64,                   // 12547:    decode to XVSSRLN_BU_H using decoder 64
                                             // 12547:   }
  2, 4,                                      // 12551:   case 0x2: {
  OPC_Decode, 247, 18, 64,                   // 12553:    decode to XVSSRLN_HU_W using decoder 64
                                             // 12553:   }
  3, 4,                                      // 12557:   case 0x3: {
  OPC_Decode, 249, 18, 64,                   // 12559:    decode to XVSSRLN_WU_D using decoder 64
                                             // 12559:   }
  5, 4,                                      // 12563:   case 0x5: {
  OPC_Decode, 217, 18, 64,                   // 12565:    decode to XVSSRAN_BU_H using decoder 64
                                             // 12565:   }
  6, 4,                                      // 12569:   case 0x6: {
  OPC_Decode, 219, 18, 64,                   // 12571:    decode to XVSSRAN_HU_W using decoder 64
                                             // 12571:   }
  7, 0,                                      // 12575:   case 0x7: {
  OPC_Decode, 221, 18, 64,                   // 12577:    decode to XVSSRAN_WU_D using decoder 64
                                             // 12577:   }
                                             // 12577:   } // switch Inst[17:15]
                                             // 12577:  }
  66, 39,                                    // 12581:  case 0x42: {
  OPC_SwitchField, 15, 3,                    // 12583:   switch Inst[17:15] {
  1, 4,                                      // 12586:   case 0x1: {
  OPC_Decode, 131, 19, 64,                   // 12588:    decode to XVSSRLRN_BU_H using decoder 64
                                             // 12588:   }
  2, 4,                                      // 12592:   case 0x2: {
  OPC_Decode, 133, 19, 64,                   // 12594:    decode to XVSSRLRN_HU_W using decoder 64
                                             // 12594:   }
  3, 4,                                      // 12598:   case 0x3: {
  OPC_Decode, 135, 19, 64,                   // 12600:    decode to XVSSRLRN_WU_D using decoder 64
                                             // 12600:   }
  5, 4,                                      // 12604:   case 0x5: {
  OPC_Decode, 231, 18, 64,                   // 12606:    decode to XVSSRARN_BU_H using decoder 64
                                             // 12606:   }
  6, 4,                                      // 12610:   case 0x6: {
  OPC_Decode, 233, 18, 64,                   // 12612:    decode to XVSSRARN_HU_W using decoder 64
                                             // 12612:   }
  7, 0,                                      // 12616:   case 0x7: {
  OPC_Decode, 235, 18, 64,                   // 12618:    decode to XVSSRARN_WU_D using decoder 64
                                             // 12618:   }
                                             // 12618:   } // switch Inst[17:15]
                                             // 12618:  }
  67, 51,                                    // 12622:  case 0x43: {
  OPC_SwitchField, 15, 3,                    // 12624:   switch Inst[17:15] {
  0, 4,                                      // 12627:   case 0x0: {
  OPC_Decode, 163, 14, 64,                   // 12629:    decode to XVBITCLR_B using decoder 64
                                             // 12629:   }
  1, 4,                                      // 12633:   case 0x1: {
  OPC_Decode, 165, 14, 64,                   // 12635:    decode to XVBITCLR_H using decoder 64
                                             // 12635:   }
  2, 4,                                      // 12639:   case 0x2: {
  OPC_Decode, 166, 14, 64,                   // 12641:    decode to XVBITCLR_W using decoder 64
                                             // 12641:   }
  3, 4,                                      // 12645:   case 0x3: {
  OPC_Decode, 164, 14, 64,                   // 12647:    decode to XVBITCLR_D using decoder 64
                                             // 12647:   }
  4, 4,                                      // 12651:   case 0x4: {
  OPC_Decode, 181, 14, 64,                   // 12653:    decode to XVBITSET_B using decoder 64
                                             // 12653:   }
  5, 4,                                      // 12657:   case 0x5: {
  OPC_Decode, 183, 14, 64,                   // 12659:    decode to XVBITSET_H using decoder 64
                                             // 12659:   }
  6, 4,                                      // 12663:   case 0x6: {
  OPC_Decode, 184, 14, 64,                   // 12665:    decode to XVBITSET_W using decoder 64
                                             // 12665:   }
  7, 0,                                      // 12669:   case 0x7: {
  OPC_Decode, 182, 14, 64,                   // 12671:    decode to XVBITSET_D using decoder 64
                                             // 12671:   }
                                             // 12671:   } // switch Inst[17:15]
                                             // 12671:  }
  68, 27,                                    // 12675:  case 0x44: {
  OPC_SwitchField, 15, 3,                    // 12677:   switch Inst[17:15] {
  0, 4,                                      // 12680:   case 0x0: {
  OPC_Decode, 171, 14, 64,                   // 12682:    decode to XVBITREV_B using decoder 64
                                             // 12682:   }
  1, 4,                                      // 12686:   case 0x1: {
  OPC_Decode, 173, 14, 64,                   // 12688:    decode to XVBITREV_H using decoder 64
                                             // 12688:   }
  2, 4,                                      // 12692:   case 0x2: {
  OPC_Decode, 174, 14, 64,                   // 12694:    decode to XVBITREV_W using decoder 64
                                             // 12694:   }
  3, 0,                                      // 12698:   case 0x3: {
  OPC_Decode, 172, 14, 64,                   // 12700:    decode to XVBITREV_D using decoder 64
                                             // 12700:   }
                                             // 12700:   } // switch Inst[17:15]
                                             // 12700:  }
  69, 27,                                    // 12704:  case 0x45: {
  OPC_SwitchField, 15, 3,                    // 12706:   switch Inst[17:15] {
  4, 4,                                      // 12709:   case 0x4: {
  OPC_Decode, 130, 17, 64,                   // 12711:    decode to XVPACKEV_B using decoder 64
                                             // 12711:   }
  5, 4,                                      // 12715:   case 0x5: {
  OPC_Decode, 132, 17, 64,                   // 12717:    decode to XVPACKEV_H using decoder 64
                                             // 12717:   }
  6, 4,                                      // 12721:   case 0x6: {
  OPC_Decode, 133, 17, 64,                   // 12723:    decode to XVPACKEV_W using decoder 64
                                             // 12723:   }
  7, 0,                                      // 12727:   case 0x7: {
  OPC_Decode, 131, 17, 64,                   // 12729:    decode to XVPACKEV_D using decoder 64
                                             // 12729:   }
                                             // 12729:   } // switch Inst[17:15]
                                             // 12729:  }
  70, 51,                                    // 12733:  case 0x46: {
  OPC_SwitchField, 15, 3,                    // 12735:   switch Inst[17:15] {
  0, 4,                                      // 12738:   case 0x0: {
  OPC_Decode, 134, 17, 64,                   // 12740:    decode to XVPACKOD_B using decoder 64
                                             // 12740:   }
  1, 4,                                      // 12744:   case 0x1: {
  OPC_Decode, 136, 17, 64,                   // 12746:    decode to XVPACKOD_H using decoder 64
                                             // 12746:   }
  2, 4,                                      // 12750:   case 0x2: {
  OPC_Decode, 137, 17, 64,                   // 12752:    decode to XVPACKOD_W using decoder 64
                                             // 12752:   }
  3, 4,                                      // 12756:   case 0x3: {
  OPC_Decode, 135, 17, 64,                   // 12758:    decode to XVPACKOD_D using decoder 64
                                             // 12758:   }
  4, 4,                                      // 12762:   case 0x4: {
  OPC_Decode, 248, 15, 64,                   // 12764:    decode to XVILVL_B using decoder 64
                                             // 12764:   }
  5, 4,                                      // 12768:   case 0x5: {
  OPC_Decode, 250, 15, 64,                   // 12770:    decode to XVILVL_H using decoder 64
                                             // 12770:   }
  6, 4,                                      // 12774:   case 0x6: {
  OPC_Decode, 251, 15, 64,                   // 12776:    decode to XVILVL_W using decoder 64
                                             // 12776:   }
  7, 0,                                      // 12780:   case 0x7: {
  OPC_Decode, 249, 15, 64,                   // 12782:    decode to XVILVL_D using decoder 64
                                             // 12782:   }
                                             // 12782:   } // switch Inst[17:15]
                                             // 12782:  }
  71, 51,                                    // 12786:  case 0x47: {
  OPC_SwitchField, 15, 3,                    // 12788:   switch Inst[17:15] {
  0, 4,                                      // 12791:   case 0x0: {
  OPC_Decode, 244, 15, 64,                   // 12793:    decode to XVILVH_B using decoder 64
                                             // 12793:   }
  1, 4,                                      // 12797:   case 0x1: {
  OPC_Decode, 246, 15, 64,                   // 12799:    decode to XVILVH_H using decoder 64
                                             // 12799:   }
  2, 4,                                      // 12803:   case 0x2: {
  OPC_Decode, 247, 15, 64,                   // 12805:    decode to XVILVH_W using decoder 64
                                             // 12805:   }
  3, 4,                                      // 12809:   case 0x3: {
  OPC_Decode, 245, 15, 64,                   // 12811:    decode to XVILVH_D using decoder 64
                                             // 12811:   }
  4, 4,                                      // 12815:   case 0x4: {
  OPC_Decode, 146, 17, 64,                   // 12817:    decode to XVPICKEV_B using decoder 64
                                             // 12817:   }
  5, 4,                                      // 12821:   case 0x5: {
  OPC_Decode, 148, 17, 64,                   // 12823:    decode to XVPICKEV_H using decoder 64
                                             // 12823:   }
  6, 4,                                      // 12827:   case 0x6: {
  OPC_Decode, 149, 17, 64,                   // 12829:    decode to XVPICKEV_W using decoder 64
                                             // 12829:   }
  7, 0,                                      // 12833:   case 0x7: {
  OPC_Decode, 147, 17, 64,                   // 12835:    decode to XVPICKEV_D using decoder 64
                                             // 12835:   }
                                             // 12835:   } // switch Inst[17:15]
                                             // 12835:  }
  72, 55,                                    // 12839:  case 0x48: {
  OPC_SwitchField, 15, 3,                    // 12841:   switch Inst[17:15] {
  0, 4,                                      // 12844:   case 0x0: {
  OPC_Decode, 150, 17, 64,                   // 12846:    decode to XVPICKOD_B using decoder 64
                                             // 12846:   }
  1, 4,                                      // 12850:   case 0x1: {
  OPC_Decode, 152, 17, 64,                   // 12852:    decode to XVPICKOD_H using decoder 64
                                             // 12852:   }
  2, 4,                                      // 12856:   case 0x2: {
  OPC_Decode, 153, 17, 64,                   // 12858:    decode to XVPICKOD_W using decoder 64
                                             // 12858:   }
  3, 4,                                      // 12862:   case 0x3: {
  OPC_Decode, 151, 17, 64,                   // 12864:    decode to XVPICKOD_D using decoder 64
                                             // 12864:   }
  4, 5,                                      // 12868:   case 0x4: {
  OPC_Decode, 173, 17, 132, 1,               // 12870:    decode to XVREPLVE_B using decoder 132
                                             // 12870:   }
  5, 5,                                      // 12875:   case 0x5: {
  OPC_Decode, 175, 17, 132, 1,               // 12877:    decode to XVREPLVE_H using decoder 132
                                             // 12877:   }
  6, 5,                                      // 12882:   case 0x6: {
  OPC_Decode, 176, 17, 132, 1,               // 12884:    decode to XVREPLVE_W using decoder 132
                                             // 12884:   }
  7, 0,                                      // 12889:   case 0x7: {
  OPC_Decode, 174, 17, 132, 1,               // 12891:    decode to XVREPLVE_D using decoder 132
                                             // 12891:   }
                                             // 12891:   } // switch Inst[17:15]
                                             // 12891:  }
  73, 27,                                    // 12896:  case 0x49: {
  OPC_SwitchField, 15, 3,                    // 12898:   switch Inst[17:15] {
  4, 4,                                      // 12901:   case 0x4: {
  OPC_Decode, 142, 14, 64,                   // 12903:    decode to XVAND_V using decoder 64
                                             // 12903:   }
  5, 4,                                      // 12907:   case 0x5: {
  OPC_Decode, 129, 17, 64,                   // 12909:    decode to XVOR_V using decoder 64
                                             // 12909:   }
  6, 4,                                      // 12913:   case 0x6: {
  OPC_Decode, 177, 19, 64,                   // 12915:    decode to XVXOR_V using decoder 64
                                             // 12915:   }
  7, 0,                                      // 12919:   case 0x7: {
  OPC_Decode, 254, 16, 64,                   // 12921:    decode to XVNOR_V using decoder 64
                                             // 12921:   }
                                             // 12921:   } // switch Inst[17:15]
                                             // 12921:  }
  74, 29,                                    // 12925:  case 0x4a: {
  OPC_SwitchField, 15, 3,                    // 12927:   switch Inst[17:15] {
  0, 4,                                      // 12930:   case 0x0: {
  OPC_Decode, 141, 14, 64,                   // 12932:    decode to XVANDN_V using decoder 64
                                             // 12932:   }
  1, 4,                                      // 12936:   case 0x1: {
  OPC_Decode, 128, 17, 64,                   // 12938:    decode to XVORN_V using decoder 64
                                             // 12938:   }
  6, 5,                                      // 12942:   case 0x6: {
  OPC_Decode, 192, 15, 131, 1,               // 12944:    decode to XVFRSTP_B using decoder 131
                                             // 12944:   }
  7, 0,                                      // 12949:   case 0x7: {
  OPC_Decode, 193, 15, 131, 1,               // 12951:    decode to XVFRSTP_H using decoder 131
                                             // 12951:   }
                                             // 12951:   } // switch Inst[17:15]
                                             // 12951:  }
  75, 39,                                    // 12956:  case 0x4b: {
  OPC_SwitchField, 15, 3,                    // 12958:   switch Inst[17:15] {
  2, 4,                                      // 12961:   case 0x2: {
  OPC_Decode, 138, 14, 64,                   // 12963:    decode to XVADD_Q using decoder 64
                                             // 12963:   }
  3, 4,                                      // 12967:   case 0x3: {
  OPC_Decode, 174, 19, 64,                   // 12969:    decode to XVSUB_Q using decoder 64
                                             // 12969:   }
  4, 4,                                      // 12973:   case 0x4: {
  OPC_Decode, 227, 17, 64,                   // 12975:    decode to XVSIGNCOV_B using decoder 64
                                             // 12975:   }
  5, 4,                                      // 12979:   case 0x5: {
  OPC_Decode, 229, 17, 64,                   // 12981:    decode to XVSIGNCOV_H using decoder 64
                                             // 12981:   }
  6, 4,                                      // 12985:   case 0x6: {
  OPC_Decode, 230, 17, 64,                   // 12987:    decode to XVSIGNCOV_W using decoder 64
                                             // 12987:   }
  7, 0,                                      // 12991:   case 0x7: {
  OPC_Decode, 228, 17, 64,                   // 12993:    decode to XVSIGNCOV_D using decoder 64
                                             // 12993:   }
                                             // 12993:   } // switch Inst[17:15]
                                             // 12993:  }
  76, 27,                                    // 12997:  case 0x4c: {
  OPC_SwitchField, 15, 3,                    // 12999:   switch Inst[17:15] {
  1, 4,                                      // 13002:   case 0x1: {
  OPC_Decode, 218, 14, 64,                   // 13004:    decode to XVFADD_S using decoder 64
                                             // 13004:   }
  2, 4,                                      // 13008:   case 0x2: {
  OPC_Decode, 217, 14, 64,                   // 13010:    decode to XVFADD_D using decoder 64
                                             // 13010:   }
  5, 4,                                      // 13014:   case 0x5: {
  OPC_Decode, 197, 15, 64,                   // 13016:    decode to XVFSUB_S using decoder 64
                                             // 13016:   }
  6, 0,                                      // 13020:   case 0x6: {
  OPC_Decode, 196, 15, 64,                   // 13022:    decode to XVFSUB_D using decoder 64
                                             // 13022:   }
                                             // 13022:   } // switch Inst[17:15]
                                             // 13022:  }
  78, 27,                                    // 13026:  case 0x4e: {
  OPC_SwitchField, 15, 3,                    // 13028:   switch Inst[17:15] {
  1, 4,                                      // 13031:   case 0x1: {
  OPC_Decode, 167, 15, 64,                   // 13033:    decode to XVFMUL_S using decoder 64
                                             // 13033:   }
  2, 4,                                      // 13037:   case 0x2: {
  OPC_Decode, 166, 15, 64,                   // 13039:    decode to XVFMUL_D using decoder 64
                                             // 13039:   }
  5, 4,                                      // 13043:   case 0x5: {
  OPC_Decode, 144, 15, 64,                   // 13045:    decode to XVFDIV_S using decoder 64
                                             // 13045:   }
  6, 0,                                      // 13049:   case 0x6: {
  OPC_Decode, 143, 15, 64,                   // 13051:    decode to XVFDIV_D using decoder 64
                                             // 13051:   }
                                             // 13051:   } // switch Inst[17:15]
                                             // 13051:  }
  79, 27,                                    // 13055:  case 0x4f: {
  OPC_SwitchField, 15, 3,                    // 13057:   switch Inst[17:15] {
  1, 4,                                      // 13060:   case 0x1: {
  OPC_Decode, 159, 15, 64,                   // 13062:    decode to XVFMAX_S using decoder 64
                                             // 13062:   }
  2, 4,                                      // 13066:   case 0x2: {
  OPC_Decode, 158, 15, 64,                   // 13068:    decode to XVFMAX_D using decoder 64
                                             // 13068:   }
  5, 4,                                      // 13072:   case 0x5: {
  OPC_Decode, 163, 15, 64,                   // 13074:    decode to XVFMIN_S using decoder 64
                                             // 13074:   }
  6, 0,                                      // 13078:   case 0x6: {
  OPC_Decode, 162, 15, 64,                   // 13080:    decode to XVFMIN_D using decoder 64
                                             // 13080:   }
                                             // 13080:   } // switch Inst[17:15]
                                             // 13080:  }
  80, 27,                                    // 13084:  case 0x50: {
  OPC_SwitchField, 15, 3,                    // 13086:   switch Inst[17:15] {
  1, 4,                                      // 13089:   case 0x1: {
  OPC_Decode, 157, 15, 64,                   // 13091:    decode to XVFMAXA_S using decoder 64
                                             // 13091:   }
  2, 4,                                      // 13095:   case 0x2: {
  OPC_Decode, 156, 15, 64,                   // 13097:    decode to XVFMAXA_D using decoder 64
                                             // 13097:   }
  5, 4,                                      // 13101:   case 0x5: {
  OPC_Decode, 161, 15, 64,                   // 13103:    decode to XVFMINA_S using decoder 64
                                             // 13103:   }
  6, 0,                                      // 13107:   case 0x6: {
  OPC_Decode, 160, 15, 64,                   // 13109:    decode to XVFMINA_D using decoder 64
                                             // 13109:   }
                                             // 13109:   } // switch Inst[17:15]
                                             // 13109:  }
  81, 15,                                    // 13113:  case 0x51: {
  OPC_SwitchField, 15, 3,                    // 13115:   switch Inst[17:15] {
  4, 4,                                      // 13118:   case 0x4: {
  OPC_Decode, 141, 15, 64,                   // 13120:    decode to XVFCVT_H_S using decoder 64
                                             // 13120:   }
  5, 0,                                      // 13124:   case 0x5: {
  OPC_Decode, 142, 15, 64,                   // 13126:    decode to XVFCVT_S_D using decoder 64
                                             // 13126:   }
                                             // 13126:   } // switch Inst[17:15]
                                             // 13126:  }
  82, 39,                                    // 13130:  case 0x52: {
  OPC_SwitchField, 15, 3,                    // 13132:   switch Inst[17:15] {
  0, 4,                                      // 13135:   case 0x0: {
  OPC_Decode, 149, 15, 64,                   // 13137:    decode to XVFFINT_S_L using decoder 64
                                             // 13137:   }
  3, 4,                                      // 13141:   case 0x3: {
  OPC_Decode, 225, 15, 64,                   // 13143:    decode to XVFTINT_W_D using decoder 64
                                             // 13143:   }
  4, 4,                                      // 13147:   case 0x4: {
  OPC_Decode, 203, 15, 64,                   // 13149:    decode to XVFTINTRM_W_D using decoder 64
                                             // 13149:   }
  5, 4,                                      // 13153:   case 0x5: {
  OPC_Decode, 213, 15, 64,                   // 13155:    decode to XVFTINTRP_W_D using decoder 64
                                             // 13155:   }
  6, 4,                                      // 13159:   case 0x6: {
  OPC_Decode, 220, 15, 64,                   // 13161:    decode to XVFTINTRZ_W_D using decoder 64
                                             // 13161:   }
  7, 0,                                      // 13165:   case 0x7: {
  OPC_Decode, 208, 15, 64,                   // 13167:    decode to XVFTINTRNE_W_D using decoder 64
                                             // 13167:   }
                                             // 13167:   } // switch Inst[17:15]
                                             // 13167:  }
  94, 24,                                    // 13171:  case 0x5e: {
  OPC_SwitchField, 15, 3,                    // 13173:   switch Inst[17:15] {
  5, 5,                                      // 13176:   case 0x5: {
  OPC_Decode, 225, 17, 131, 1,               // 13178:    decode to XVSHUF_H using decoder 131
                                             // 13178:   }
  6, 5,                                      // 13183:   case 0x6: {
  OPC_Decode, 226, 17, 131, 1,               // 13185:    decode to XVSHUF_W using decoder 131
                                             // 13185:   }
  7, 0,                                      // 13190:   case 0x7: {
  OPC_Decode, 224, 17, 131, 1,               // 13192:    decode to XVSHUF_D using decoder 131
                                             // 13192:   }
                                             // 13192:   } // switch Inst[17:15]
                                             // 13192:  }
  95, 8,                                     // 13197:  case 0x5f: {
  OPC_CheckField, 15, 3, 2,                  // 13199:   check Inst[17:15] == 0x2
  OPC_Decode, 145, 17, 64,                   // 13203:   decode to XVPERM_W using decoder 64
                                             // 13203:  }
  160, 1, 59,                                // 13207:  case 0xa0: {
  OPC_SwitchField, 15, 3,                    // 13210:   switch Inst[17:15] {
  0, 5,                                      // 13213:   case 0x0: {
  OPC_Decode, 201, 17, 133, 1,               // 13215:    decode to XVSEQI_B using decoder 133
                                             // 13215:   }
  1, 5,                                      // 13220:   case 0x1: {
  OPC_Decode, 203, 17, 133, 1,               // 13222:    decode to XVSEQI_H using decoder 133
                                             // 13222:   }
  2, 5,                                      // 13227:   case 0x2: {
  OPC_Decode, 204, 17, 133, 1,               // 13229:    decode to XVSEQI_W using decoder 133
                                             // 13229:   }
  3, 5,                                      // 13234:   case 0x3: {
  OPC_Decode, 202, 17, 133, 1,               // 13236:    decode to XVSEQI_D using decoder 133
                                             // 13236:   }
  4, 5,                                      // 13241:   case 0x4: {
  OPC_Decode, 231, 17, 133, 1,               // 13243:    decode to XVSLEI_B using decoder 133
                                             // 13243:   }
  5, 5,                                      // 13248:   case 0x5: {
  OPC_Decode, 235, 17, 133, 1,               // 13250:    decode to XVSLEI_H using decoder 133
                                             // 13250:   }
  6, 5,                                      // 13255:   case 0x6: {
  OPC_Decode, 237, 17, 133, 1,               // 13257:    decode to XVSLEI_W using decoder 133
                                             // 13257:   }
  7, 0,                                      // 13262:   case 0x7: {
  OPC_Decode, 233, 17, 133, 1,               // 13264:    decode to XVSLEI_D using decoder 133
                                             // 13264:   }
                                             // 13264:   } // switch Inst[17:15]
                                             // 13264:  }
  161, 1, 59,                                // 13269:  case 0xa1: {
  OPC_SwitchField, 15, 3,                    // 13272:   switch Inst[17:15] {
  0, 5,                                      // 13275:   case 0x0: {
  OPC_Decode, 232, 17, 134, 1,               // 13277:    decode to XVSLEI_BU using decoder 134
                                             // 13277:   }
  1, 5,                                      // 13282:   case 0x1: {
  OPC_Decode, 236, 17, 134, 1,               // 13284:    decode to XVSLEI_HU using decoder 134
                                             // 13284:   }
  2, 5,                                      // 13289:   case 0x2: {
  OPC_Decode, 238, 17, 134, 1,               // 13291:    decode to XVSLEI_WU using decoder 134
                                             // 13291:   }
  3, 5,                                      // 13296:   case 0x3: {
  OPC_Decode, 234, 17, 134, 1,               // 13298:    decode to XVSLEI_DU using decoder 134
                                             // 13298:   }
  4, 5,                                      // 13303:   case 0x4: {
  OPC_Decode, 133, 18, 133, 1,               // 13305:    decode to XVSLTI_B using decoder 133
                                             // 13305:   }
  5, 5,                                      // 13310:   case 0x5: {
  OPC_Decode, 137, 18, 133, 1,               // 13312:    decode to XVSLTI_H using decoder 133
                                             // 13312:   }
  6, 5,                                      // 13317:   case 0x6: {
  OPC_Decode, 139, 18, 133, 1,               // 13319:    decode to XVSLTI_W using decoder 133
                                             // 13319:   }
  7, 0,                                      // 13324:   case 0x7: {
  OPC_Decode, 135, 18, 133, 1,               // 13326:    decode to XVSLTI_D using decoder 133
                                             // 13326:   }
                                             // 13326:   } // switch Inst[17:15]
                                             // 13326:  }
  162, 1, 59,                                // 13331:  case 0xa2: {
  OPC_SwitchField, 15, 3,                    // 13334:   switch Inst[17:15] {
  0, 5,                                      // 13337:   case 0x0: {
  OPC_Decode, 134, 18, 134, 1,               // 13339:    decode to XVSLTI_BU using decoder 134
                                             // 13339:   }
  1, 5,                                      // 13344:   case 0x1: {
  OPC_Decode, 138, 18, 134, 1,               // 13346:    decode to XVSLTI_HU using decoder 134
                                             // 13346:   }
  2, 5,                                      // 13351:   case 0x2: {
  OPC_Decode, 140, 18, 134, 1,               // 13353:    decode to XVSLTI_WU using decoder 134
                                             // 13353:   }
  3, 5,                                      // 13358:   case 0x3: {
  OPC_Decode, 136, 18, 134, 1,               // 13360:    decode to XVSLTI_DU using decoder 134
                                             // 13360:   }
  4, 5,                                      // 13365:   case 0x4: {
  OPC_Decode, 235, 13, 134, 1,               // 13367:    decode to XVADDI_BU using decoder 134
                                             // 13367:   }
  5, 5,                                      // 13372:   case 0x5: {
  OPC_Decode, 237, 13, 134, 1,               // 13374:    decode to XVADDI_HU using decoder 134
                                             // 13374:   }
  6, 5,                                      // 13379:   case 0x6: {
  OPC_Decode, 238, 13, 134, 1,               // 13381:    decode to XVADDI_WU using decoder 134
                                             // 13381:   }
  7, 0,                                      // 13386:   case 0x7: {
  OPC_Decode, 236, 13, 134, 1,               // 13388:    decode to XVADDI_DU using decoder 134
                                             // 13388:   }
                                             // 13388:   } // switch Inst[17:15]
                                             // 13388:  }
  163, 1, 45,                                // 13393:  case 0xa3: {
  OPC_SwitchField, 15, 3,                    // 13396:   switch Inst[17:15] {
  0, 5,                                      // 13399:   case 0x0: {
  OPC_Decode, 151, 19, 134, 1,               // 13401:    decode to XVSUBI_BU using decoder 134
                                             // 13401:   }
  1, 5,                                      // 13406:   case 0x1: {
  OPC_Decode, 153, 19, 134, 1,               // 13408:    decode to XVSUBI_HU using decoder 134
                                             // 13408:   }
  2, 5,                                      // 13413:   case 0x2: {
  OPC_Decode, 154, 19, 134, 1,               // 13415:    decode to XVSUBI_WU using decoder 134
                                             // 13415:   }
  3, 5,                                      // 13420:   case 0x3: {
  OPC_Decode, 152, 19, 134, 1,               // 13422:    decode to XVSUBI_DU using decoder 134
                                             // 13422:   }
  4, 5,                                      // 13427:   case 0x4: {
  OPC_Decode, 185, 14, 134, 1,               // 13429:    decode to XVBSLL_V using decoder 134
                                             // 13429:   }
  5, 0,                                      // 13434:   case 0x5: {
  OPC_Decode, 186, 14, 134, 1,               // 13436:    decode to XVBSRL_V using decoder 134
                                             // 13436:   }
                                             // 13436:   } // switch Inst[17:15]
                                             // 13436:  }
  164, 1, 59,                                // 13441:  case 0xa4: {
  OPC_SwitchField, 15, 3,                    // 13444:   switch Inst[17:15] {
  0, 5,                                      // 13447:   case 0x0: {
  OPC_Decode, 163, 16, 133, 1,               // 13449:    decode to XVMAXI_B using decoder 133
                                             // 13449:   }
  1, 5,                                      // 13454:   case 0x1: {
  OPC_Decode, 167, 16, 133, 1,               // 13456:    decode to XVMAXI_H using decoder 133
                                             // 13456:   }
  2, 5,                                      // 13461:   case 0x2: {
  OPC_Decode, 169, 16, 133, 1,               // 13463:    decode to XVMAXI_W using decoder 133
                                             // 13463:   }
  3, 5,                                      // 13468:   case 0x3: {
  OPC_Decode, 165, 16, 133, 1,               // 13470:    decode to XVMAXI_D using decoder 133
                                             // 13470:   }
  4, 5,                                      // 13475:   case 0x4: {
  OPC_Decode, 179, 16, 133, 1,               // 13477:    decode to XVMINI_B using decoder 133
                                             // 13477:   }
  5, 5,                                      // 13482:   case 0x5: {
  OPC_Decode, 183, 16, 133, 1,               // 13484:    decode to XVMINI_H using decoder 133
                                             // 13484:   }
  6, 5,                                      // 13489:   case 0x6: {
  OPC_Decode, 185, 16, 133, 1,               // 13491:    decode to XVMINI_W using decoder 133
                                             // 13491:   }
  7, 0,                                      // 13496:   case 0x7: {
  OPC_Decode, 181, 16, 133, 1,               // 13498:    decode to XVMINI_D using decoder 133
                                             // 13498:   }
                                             // 13498:   } // switch Inst[17:15]
                                             // 13498:  }
  165, 1, 59,                                // 13503:  case 0xa5: {
  OPC_SwitchField, 15, 3,                    // 13506:   switch Inst[17:15] {
  0, 5,                                      // 13509:   case 0x0: {
  OPC_Decode, 164, 16, 134, 1,               // 13511:    decode to XVMAXI_BU using decoder 134
                                             // 13511:   }
  1, 5,                                      // 13516:   case 0x1: {
  OPC_Decode, 168, 16, 134, 1,               // 13518:    decode to XVMAXI_HU using decoder 134
                                             // 13518:   }
  2, 5,                                      // 13523:   case 0x2: {
  OPC_Decode, 170, 16, 134, 1,               // 13525:    decode to XVMAXI_WU using decoder 134
                                             // 13525:   }
  3, 5,                                      // 13530:   case 0x3: {
  OPC_Decode, 166, 16, 134, 1,               // 13532:    decode to XVMAXI_DU using decoder 134
                                             // 13532:   }
  4, 5,                                      // 13537:   case 0x4: {
  OPC_Decode, 180, 16, 134, 1,               // 13539:    decode to XVMINI_BU using decoder 134
                                             // 13539:   }
  5, 5,                                      // 13544:   case 0x5: {
  OPC_Decode, 184, 16, 134, 1,               // 13546:    decode to XVMINI_HU using decoder 134
                                             // 13546:   }
  6, 5,                                      // 13551:   case 0x6: {
  OPC_Decode, 186, 16, 134, 1,               // 13553:    decode to XVMINI_WU using decoder 134
                                             // 13553:   }
  7, 0,                                      // 13558:   case 0x7: {
  OPC_Decode, 182, 16, 134, 1,               // 13560:    decode to XVMINI_DU using decoder 134
                                             // 13560:   }
                                             // 13560:   } // switch Inst[17:15]
                                             // 13560:  }
  166, 1, 17,                                // 13565:  case 0xa6: {
  OPC_SwitchField, 15, 3,                    // 13568:   switch Inst[17:15] {
  4, 5,                                      // 13571:   case 0x4: {
  OPC_Decode, 190, 15, 135, 1,               // 13573:    decode to XVFRSTPI_B using decoder 135
                                             // 13573:   }
  5, 0,                                      // 13578:   case 0x5: {
  OPC_Decode, 191, 15, 135, 1,               // 13580:    decode to XVFRSTPI_H using decoder 135
                                             // 13580:   }
                                             // 13580:   } // switch Inst[17:15]
                                             // 13580:  }
  167, 1, 247, 6,                            // 13585:  case 0xa7: {
  OPC_SwitchField, 15, 3,                    // 13589:   switch Inst[17:15] {
  0, 157, 1,                                 // 13592:   case 0x0: {
  OPC_SwitchField, 10, 5,                    // 13595:    switch Inst[14:10] {
  0, 5,                                      // 13598:    case 0x0: {
  OPC_Decode, 187, 14, 136, 1,               // 13600:     decode to XVCLO_B using decoder 136
                                             // 13600:    }
  1, 5,                                      // 13605:    case 0x1: {
  OPC_Decode, 189, 14, 136, 1,               // 13607:     decode to XVCLO_H using decoder 136
                                             // 13607:    }
  2, 5,                                      // 13612:    case 0x2: {
  OPC_Decode, 190, 14, 136, 1,               // 13614:     decode to XVCLO_W using decoder 136
                                             // 13614:    }
  3, 5,                                      // 13619:    case 0x3: {
  OPC_Decode, 188, 14, 136, 1,               // 13621:     decode to XVCLO_D using decoder 136
                                             // 13621:    }
  4, 5,                                      // 13626:    case 0x4: {
  OPC_Decode, 191, 14, 136, 1,               // 13628:     decode to XVCLZ_B using decoder 136
                                             // 13628:    }
  5, 5,                                      // 13633:    case 0x5: {
  OPC_Decode, 193, 14, 136, 1,               // 13635:     decode to XVCLZ_H using decoder 136
                                             // 13635:    }
  6, 5,                                      // 13640:    case 0x6: {
  OPC_Decode, 194, 14, 136, 1,               // 13642:     decode to XVCLZ_W using decoder 136
                                             // 13642:    }
  7, 5,                                      // 13647:    case 0x7: {
  OPC_Decode, 192, 14, 136, 1,               // 13649:     decode to XVCLZ_D using decoder 136
                                             // 13649:    }
  8, 5,                                      // 13654:    case 0x8: {
  OPC_Decode, 138, 17, 136, 1,               // 13656:     decode to XVPCNT_B using decoder 136
                                             // 13656:    }
  9, 5,                                      // 13661:    case 0x9: {
  OPC_Decode, 140, 17, 136, 1,               // 13663:     decode to XVPCNT_H using decoder 136
                                             // 13663:    }
  10, 5,                                     // 13668:    case 0xa: {
  OPC_Decode, 141, 17, 136, 1,               // 13670:     decode to XVPCNT_W using decoder 136
                                             // 13670:    }
  11, 5,                                     // 13675:    case 0xb: {
  OPC_Decode, 139, 17, 136, 1,               // 13677:     decode to XVPCNT_D using decoder 136
                                             // 13677:    }
  12, 5,                                     // 13682:    case 0xc: {
  OPC_Decode, 249, 16, 136, 1,               // 13684:     decode to XVNEG_B using decoder 136
                                             // 13684:    }
  13, 5,                                     // 13689:    case 0xd: {
  OPC_Decode, 251, 16, 136, 1,               // 13691:     decode to XVNEG_H using decoder 136
                                             // 13691:    }
  14, 5,                                     // 13696:    case 0xe: {
  OPC_Decode, 252, 16, 136, 1,               // 13698:     decode to XVNEG_W using decoder 136
                                             // 13698:    }
  15, 5,                                     // 13703:    case 0xf: {
  OPC_Decode, 250, 16, 136, 1,               // 13705:     decode to XVNEG_D using decoder 136
                                             // 13705:    }
  16, 5,                                     // 13710:    case 0x10: {
  OPC_Decode, 204, 16, 136, 1,               // 13712:     decode to XVMSKLTZ_B using decoder 136
                                             // 13712:    }
  17, 5,                                     // 13717:    case 0x11: {
  OPC_Decode, 206, 16, 136, 1,               // 13719:     decode to XVMSKLTZ_H using decoder 136
                                             // 13719:    }
  18, 5,                                     // 13724:    case 0x12: {
  OPC_Decode, 207, 16, 136, 1,               // 13726:     decode to XVMSKLTZ_W using decoder 136
                                             // 13726:    }
  19, 5,                                     // 13731:    case 0x13: {
  OPC_Decode, 205, 16, 136, 1,               // 13733:     decode to XVMSKLTZ_D using decoder 136
                                             // 13733:    }
  20, 5,                                     // 13738:    case 0x14: {
  OPC_Decode, 203, 16, 136, 1,               // 13740:     decode to XVMSKGEZ_B using decoder 136
                                             // 13740:    }
  24, 0,                                     // 13745:    case 0x18: {
  OPC_Decode, 208, 16, 136, 1,               // 13747:     decode to XVMSKNZ_B using decoder 136
                                             // 13747:    }
                                             // 13747:    } // switch Inst[14:10]
                                             // 13747:   }
  1, 169, 1,                                 // 13752:   case 0x1: {
  OPC_SwitchField, 10, 5,                    // 13755:    switch Inst[14:10] {
  6, 9,                                      // 13758:    case 0x6: {
  OPC_CheckField, 3, 2, 0,                   // 13760:     check Inst[4:3] == 0x0
  OPC_Decode, 217, 17, 137, 1,               // 13764:     decode to XVSETEQZ_V using decoder 137
                                             // 13764:    }
  7, 9,                                      // 13769:    case 0x7: {
  OPC_CheckField, 3, 2, 0,                   // 13771:     check Inst[4:3] == 0x0
  OPC_Decode, 218, 17, 137, 1,               // 13775:     decode to XVSETNEZ_V using decoder 137
                                             // 13775:    }
  8, 9,                                      // 13780:    case 0x8: {
  OPC_CheckField, 3, 2, 0,                   // 13782:     check Inst[4:3] == 0x0
  OPC_Decode, 213, 17, 137, 1,               // 13786:     decode to XVSETANYEQZ_B using decoder 137
                                             // 13786:    }
  9, 9,                                      // 13791:    case 0x9: {
  OPC_CheckField, 3, 2, 0,                   // 13793:     check Inst[4:3] == 0x0
  OPC_Decode, 215, 17, 137, 1,               // 13797:     decode to XVSETANYEQZ_H using decoder 137
                                             // 13797:    }
  10, 9,                                     // 13802:    case 0xa: {
  OPC_CheckField, 3, 2, 0,                   // 13804:     check Inst[4:3] == 0x0
  OPC_Decode, 216, 17, 137, 1,               // 13808:     decode to XVSETANYEQZ_W using decoder 137
                                             // 13808:    }
  11, 9,                                     // 13813:    case 0xb: {
  OPC_CheckField, 3, 2, 0,                   // 13815:     check Inst[4:3] == 0x0
  OPC_Decode, 214, 17, 137, 1,               // 13819:     decode to XVSETANYEQZ_D using decoder 137
                                             // 13819:    }
  12, 9,                                     // 13824:    case 0xc: {
  OPC_CheckField, 3, 2, 0,                   // 13826:     check Inst[4:3] == 0x0
  OPC_Decode, 209, 17, 137, 1,               // 13830:     decode to XVSETALLNEZ_B using decoder 137
                                             // 13830:    }
  13, 9,                                     // 13835:    case 0xd: {
  OPC_CheckField, 3, 2, 0,                   // 13837:     check Inst[4:3] == 0x0
  OPC_Decode, 211, 17, 137, 1,               // 13841:     decode to XVSETALLNEZ_H using decoder 137
                                             // 13841:    }
  14, 9,                                     // 13846:    case 0xe: {
  OPC_CheckField, 3, 2, 0,                   // 13848:     check Inst[4:3] == 0x0
  OPC_Decode, 212, 17, 137, 1,               // 13852:     decode to XVSETALLNEZ_W using decoder 137
                                             // 13852:    }
  15, 9,                                     // 13857:    case 0xf: {
  OPC_CheckField, 3, 2, 0,                   // 13859:     check Inst[4:3] == 0x0
  OPC_Decode, 210, 17, 137, 1,               // 13863:     decode to XVSETALLNEZ_D using decoder 137
                                             // 13863:    }
  17, 5,                                     // 13868:    case 0x11: {
  OPC_Decode, 153, 15, 136, 1,               // 13870:     decode to XVFLOGB_S using decoder 136
                                             // 13870:    }
  18, 5,                                     // 13875:    case 0x12: {
  OPC_Decode, 152, 15, 136, 1,               // 13877:     decode to XVFLOGB_D using decoder 136
                                             // 13877:    }
  21, 5,                                     // 13882:    case 0x15: {
  OPC_Decode, 220, 14, 136, 1,               // 13884:     decode to XVFCLASS_S using decoder 136
                                             // 13884:    }
  22, 5,                                     // 13889:    case 0x16: {
  OPC_Decode, 219, 14, 136, 1,               // 13891:     decode to XVFCLASS_D using decoder 136
                                             // 13891:    }
  25, 5,                                     // 13896:    case 0x19: {
  OPC_Decode, 195, 15, 136, 1,               // 13898:     decode to XVFSQRT_S using decoder 136
                                             // 13898:    }
  26, 5,                                     // 13903:    case 0x1a: {
  OPC_Decode, 194, 15, 136, 1,               // 13905:     decode to XVFSQRT_D using decoder 136
                                             // 13905:    }
  29, 5,                                     // 13910:    case 0x1d: {
  OPC_Decode, 175, 15, 136, 1,               // 13912:     decode to XVFRECIP_S using decoder 136
                                             // 13912:    }
  30, 0,                                     // 13917:    case 0x1e: {
  OPC_Decode, 174, 15, 136, 1,               // 13919:     decode to XVFRECIP_D using decoder 136
                                             // 13919:    }
                                             // 13919:    } // switch Inst[14:10]
                                             // 13919:   }
  2, 115,                                    // 13924:   case 0x2: {
  OPC_SwitchField, 10, 5,                    // 13926:    switch Inst[14:10] {
  1, 5,                                      // 13929:    case 0x1: {
  OPC_Decode, 189, 15, 136, 1,               // 13931:     decode to XVFRSQRT_S using decoder 136
                                             // 13931:    }
  2, 5,                                      // 13936:    case 0x2: {
  OPC_Decode, 188, 15, 136, 1,               // 13938:     decode to XVFRSQRT_D using decoder 136
                                             // 13938:    }
  5, 5,                                      // 13943:    case 0x5: {
  OPC_Decode, 173, 15, 136, 1,               // 13945:     decode to XVFRECIPE_S using decoder 136
                                             // 13945:    }
  6, 5,                                      // 13950:    case 0x6: {
  OPC_Decode, 172, 15, 136, 1,               // 13952:     decode to XVFRECIPE_D using decoder 136
                                             // 13952:    }
  9, 5,                                      // 13957:    case 0x9: {
  OPC_Decode, 187, 15, 136, 1,               // 13959:     decode to XVFRSQRTE_S using decoder 136
                                             // 13959:    }
  10, 5,                                     // 13964:    case 0xa: {
  OPC_Decode, 186, 15, 136, 1,               // 13966:     decode to XVFRSQRTE_D using decoder 136
                                             // 13966:    }
  13, 5,                                     // 13971:    case 0xd: {
  OPC_Decode, 185, 15, 136, 1,               // 13973:     decode to XVFRINT_S using decoder 136
                                             // 13973:    }
  14, 5,                                     // 13978:    case 0xe: {
  OPC_Decode, 184, 15, 136, 1,               // 13980:     decode to XVFRINT_D using decoder 136
                                             // 13980:    }
  17, 5,                                     // 13985:    case 0x11: {
  OPC_Decode, 177, 15, 136, 1,               // 13987:     decode to XVFRINTRM_S using decoder 136
                                             // 13987:    }
  18, 5,                                     // 13992:    case 0x12: {
  OPC_Decode, 176, 15, 136, 1,               // 13994:     decode to XVFRINTRM_D using decoder 136
                                             // 13994:    }
  21, 5,                                     // 13999:    case 0x15: {
  OPC_Decode, 181, 15, 136, 1,               // 14001:     decode to XVFRINTRP_S using decoder 136
                                             // 14001:    }
  22, 5,                                     // 14006:    case 0x16: {
  OPC_Decode, 180, 15, 136, 1,               // 14008:     decode to XVFRINTRP_D using decoder 136
                                             // 14008:    }
  25, 5,                                     // 14013:    case 0x19: {
  OPC_Decode, 183, 15, 136, 1,               // 14015:     decode to XVFRINTRZ_S using decoder 136
                                             // 14015:    }
  26, 5,                                     // 14020:    case 0x1a: {
  OPC_Decode, 182, 15, 136, 1,               // 14022:     decode to XVFRINTRZ_D using decoder 136
                                             // 14022:    }
  29, 5,                                     // 14027:    case 0x1d: {
  OPC_Decode, 179, 15, 136, 1,               // 14029:     decode to XVFRINTRNE_S using decoder 136
                                             // 14029:    }
  30, 0,                                     // 14034:    case 0x1e: {
  OPC_Decode, 178, 15, 136, 1,               // 14036:     decode to XVFRINTRNE_D using decoder 136
                                             // 14036:    }
                                             // 14036:    } // switch Inst[14:10]
                                             // 14036:   }
  3, 31,                                     // 14041:   case 0x3: {
  OPC_SwitchField, 10, 5,                    // 14043:    switch Inst[14:10] {
  26, 5,                                     // 14046:    case 0x1a: {
  OPC_Decode, 140, 15, 136, 1,               // 14048:     decode to XVFCVTL_S_H using decoder 136
                                             // 14048:    }
  27, 5,                                     // 14053:    case 0x1b: {
  OPC_Decode, 138, 15, 136, 1,               // 14055:     decode to XVFCVTH_S_H using decoder 136
                                             // 14055:    }
  28, 5,                                     // 14060:    case 0x1c: {
  OPC_Decode, 139, 15, 136, 1,               // 14062:     decode to XVFCVTL_D_S using decoder 136
                                             // 14062:    }
  29, 0,                                     // 14067:    case 0x1d: {
  OPC_Decode, 137, 15, 136, 1,               // 14069:     decode to XVFCVTH_D_S using decoder 136
                                             // 14069:    }
                                             // 14069:    } // switch Inst[14:10]
                                             // 14069:   }
  4, 143, 1,                                 // 14074:   case 0x4: {
  OPC_SwitchField, 10, 5,                    // 14077:    switch Inst[14:10] {
  0, 5,                                      // 14080:    case 0x0: {
  OPC_Decode, 150, 15, 136, 1,               // 14082:     decode to XVFFINT_S_W using decoder 136
                                             // 14082:    }
  1, 5,                                      // 14087:    case 0x1: {
  OPC_Decode, 151, 15, 136, 1,               // 14089:     decode to XVFFINT_S_WU using decoder 136
                                             // 14089:    }
  2, 5,                                      // 14094:    case 0x2: {
  OPC_Decode, 147, 15, 136, 1,               // 14096:     decode to XVFFINT_D_L using decoder 136
                                             // 14096:    }
  3, 5,                                      // 14101:    case 0x3: {
  OPC_Decode, 148, 15, 136, 1,               // 14103:     decode to XVFFINT_D_LU using decoder 136
                                             // 14103:    }
  4, 5,                                      // 14108:    case 0x4: {
  OPC_Decode, 146, 15, 136, 1,               // 14110:     decode to XVFFINTL_D_W using decoder 136
                                             // 14110:    }
  5, 5,                                      // 14115:    case 0x5: {
  OPC_Decode, 145, 15, 136, 1,               // 14117:     decode to XVFFINTH_D_W using decoder 136
                                             // 14117:    }
  12, 5,                                     // 14122:    case 0xc: {
  OPC_Decode, 226, 15, 136, 1,               // 14124:     decode to XVFTINT_W_S using decoder 136
                                             // 14124:    }
  13, 5,                                     // 14129:    case 0xd: {
  OPC_Decode, 223, 15, 136, 1,               // 14131:     decode to XVFTINT_L_D using decoder 136
                                             // 14131:    }
  14, 5,                                     // 14136:    case 0xe: {
  OPC_Decode, 204, 15, 136, 1,               // 14138:     decode to XVFTINTRM_W_S using decoder 136
                                             // 14138:    }
  15, 5,                                     // 14143:    case 0xf: {
  OPC_Decode, 202, 15, 136, 1,               // 14145:     decode to XVFTINTRM_L_D using decoder 136
                                             // 14145:    }
  16, 5,                                     // 14150:    case 0x10: {
  OPC_Decode, 214, 15, 136, 1,               // 14152:     decode to XVFTINTRP_W_S using decoder 136
                                             // 14152:    }
  17, 5,                                     // 14157:    case 0x11: {
  OPC_Decode, 212, 15, 136, 1,               // 14159:     decode to XVFTINTRP_L_D using decoder 136
                                             // 14159:    }
  18, 5,                                     // 14164:    case 0x12: {
  OPC_Decode, 221, 15, 136, 1,               // 14166:     decode to XVFTINTRZ_W_S using decoder 136
                                             // 14166:    }
  19, 5,                                     // 14171:    case 0x13: {
  OPC_Decode, 218, 15, 136, 1,               // 14173:     decode to XVFTINTRZ_L_D using decoder 136
                                             // 14173:    }
  20, 5,                                     // 14178:    case 0x14: {
  OPC_Decode, 209, 15, 136, 1,               // 14180:     decode to XVFTINTRNE_W_S using decoder 136
                                             // 14180:    }
  21, 5,                                     // 14185:    case 0x15: {
  OPC_Decode, 207, 15, 136, 1,               // 14187:     decode to XVFTINTRNE_L_D using decoder 136
                                             // 14187:    }
  22, 5,                                     // 14192:    case 0x16: {
  OPC_Decode, 224, 15, 136, 1,               // 14194:     decode to XVFTINT_WU_S using decoder 136
                                             // 14194:    }
  23, 5,                                     // 14199:    case 0x17: {
  OPC_Decode, 222, 15, 136, 1,               // 14201:     decode to XVFTINT_LU_D using decoder 136
                                             // 14201:    }
  28, 5,                                     // 14206:    case 0x1c: {
  OPC_Decode, 219, 15, 136, 1,               // 14208:     decode to XVFTINTRZ_WU_S using decoder 136
                                             // 14208:    }
  29, 0,                                     // 14213:    case 0x1d: {
  OPC_Decode, 217, 15, 136, 1,               // 14215:     decode to XVFTINTRZ_LU_D using decoder 136
                                             // 14215:    }
                                             // 14215:    } // switch Inst[14:10]
                                             // 14215:   }
  5, 129, 1,                                 // 14220:   case 0x5: {
  OPC_SwitchField, 10, 5,                    // 14223:    switch Inst[14:10] {
  0, 5,                                      // 14226:    case 0x0: {
  OPC_Decode, 199, 15, 136, 1,               // 14228:     decode to XVFTINTL_L_S using decoder 136
                                             // 14228:    }
  1, 5,                                      // 14233:    case 0x1: {
  OPC_Decode, 198, 15, 136, 1,               // 14235:     decode to XVFTINTH_L_S using decoder 136
                                             // 14235:    }
  2, 5,                                      // 14240:    case 0x2: {
  OPC_Decode, 201, 15, 136, 1,               // 14242:     decode to XVFTINTRML_L_S using decoder 136
                                             // 14242:    }
  3, 5,                                      // 14247:    case 0x3: {
  OPC_Decode, 200, 15, 136, 1,               // 14249:     decode to XVFTINTRMH_L_S using decoder 136
                                             // 14249:    }
  4, 5,                                      // 14254:    case 0x4: {
  OPC_Decode, 211, 15, 136, 1,               // 14256:     decode to XVFTINTRPL_L_S using decoder 136
                                             // 14256:    }
  5, 5,                                      // 14261:    case 0x5: {
  OPC_Decode, 210, 15, 136, 1,               // 14263:     decode to XVFTINTRPH_L_S using decoder 136
                                             // 14263:    }
  6, 5,                                      // 14268:    case 0x6: {
  OPC_Decode, 216, 15, 136, 1,               // 14270:     decode to XVFTINTRZL_L_S using decoder 136
                                             // 14270:    }
  7, 5,                                      // 14275:    case 0x7: {
  OPC_Decode, 215, 15, 136, 1,               // 14277:     decode to XVFTINTRZH_L_S using decoder 136
                                             // 14277:    }
  8, 5,                                      // 14282:    case 0x8: {
  OPC_Decode, 206, 15, 136, 1,               // 14284:     decode to XVFTINTRNEL_L_S using decoder 136
                                             // 14284:    }
  9, 5,                                      // 14289:    case 0x9: {
  OPC_Decode, 205, 15, 136, 1,               // 14291:     decode to XVFTINTRNEH_L_S using decoder 136
                                             // 14291:    }
  24, 5,                                     // 14296:    case 0x18: {
  OPC_Decode, 206, 14, 136, 1,               // 14298:     decode to XVEXTH_H_B using decoder 136
                                             // 14298:    }
  25, 5,                                     // 14303:    case 0x19: {
  OPC_Decode, 210, 14, 136, 1,               // 14305:     decode to XVEXTH_W_H using decoder 136
                                             // 14305:    }
  26, 5,                                     // 14310:    case 0x1a: {
  OPC_Decode, 204, 14, 136, 1,               // 14312:     decode to XVEXTH_D_W using decoder 136
                                             // 14312:    }
  27, 5,                                     // 14317:    case 0x1b: {
  OPC_Decode, 208, 14, 136, 1,               // 14319:     decode to XVEXTH_Q_D using decoder 136
                                             // 14319:    }
  28, 5,                                     // 14324:    case 0x1c: {
  OPC_Decode, 205, 14, 136, 1,               // 14326:     decode to XVEXTH_HU_BU using decoder 136
                                             // 14326:    }
  29, 5,                                     // 14331:    case 0x1d: {
  OPC_Decode, 209, 14, 136, 1,               // 14333:     decode to XVEXTH_WU_HU using decoder 136
                                             // 14333:    }
  30, 5,                                     // 14338:    case 0x1e: {
  OPC_Decode, 203, 14, 136, 1,               // 14340:     decode to XVEXTH_DU_WU using decoder 136
                                             // 14340:    }
  31, 0,                                     // 14345:    case 0x1f: {
  OPC_Decode, 207, 14, 136, 1,               // 14347:     decode to XVEXTH_QU_DU using decoder 136
                                             // 14347:    }
                                             // 14347:    } // switch Inst[14:10]
                                             // 14347:   }
  6, 115,                                    // 14352:   case 0x6: {
  OPC_SwitchField, 10, 5,                    // 14354:    switch Inst[14:10] {
  0, 5,                                      // 14357:    case 0x0: {
  OPC_Decode, 164, 17, 138, 1,               // 14359:     decode to XVREPLGR2VR_B using decoder 138
                                             // 14359:    }
  1, 5,                                      // 14364:    case 0x1: {
  OPC_Decode, 166, 17, 138, 1,               // 14366:     decode to XVREPLGR2VR_H using decoder 138
                                             // 14366:    }
  2, 5,                                      // 14371:    case 0x2: {
  OPC_Decode, 167, 17, 138, 1,               // 14373:     decode to XVREPLGR2VR_W using decoder 138
                                             // 14373:    }
  3, 5,                                      // 14378:    case 0x3: {
  OPC_Decode, 165, 17, 138, 1,               // 14380:     decode to XVREPLGR2VR_D using decoder 138
                                             // 14380:    }
  4, 5,                                      // 14385:    case 0x4: {
  OPC_Decode, 135, 8, 136, 1,                // 14387:     decode to VEXT2XV_H_B using decoder 136
                                             // 14387:    }
  5, 5,                                      // 14392:    case 0x5: {
  OPC_Decode, 138, 8, 136, 1,                // 14394:     decode to VEXT2XV_W_B using decoder 136
                                             // 14394:    }
  6, 5,                                      // 14399:    case 0x6: {
  OPC_Decode, 131, 8, 136, 1,                // 14401:     decode to VEXT2XV_D_B using decoder 136
                                             // 14401:    }
  7, 5,                                      // 14406:    case 0x7: {
  OPC_Decode, 139, 8, 136, 1,                // 14408:     decode to VEXT2XV_W_H using decoder 136
                                             // 14408:    }
  8, 5,                                      // 14413:    case 0x8: {
  OPC_Decode, 132, 8, 136, 1,                // 14415:     decode to VEXT2XV_D_H using decoder 136
                                             // 14415:    }
  9, 5,                                      // 14420:    case 0x9: {
  OPC_Decode, 133, 8, 136, 1,                // 14422:     decode to VEXT2XV_D_W using decoder 136
                                             // 14422:    }
  10, 5,                                     // 14427:    case 0xa: {
  OPC_Decode, 134, 8, 136, 1,                // 14429:     decode to VEXT2XV_HU_BU using decoder 136
                                             // 14429:    }
  11, 5,                                     // 14434:    case 0xb: {
  OPC_Decode, 136, 8, 136, 1,                // 14436:     decode to VEXT2XV_WU_BU using decoder 136
                                             // 14436:    }
  12, 5,                                     // 14441:    case 0xc: {
  OPC_Decode, 128, 8, 136, 1,                // 14443:     decode to VEXT2XV_DU_BU using decoder 136
                                             // 14443:    }
  13, 5,                                     // 14448:    case 0xd: {
  OPC_Decode, 137, 8, 136, 1,                // 14450:     decode to VEXT2XV_WU_HU using decoder 136
                                             // 14450:    }
  14, 5,                                     // 14455:    case 0xe: {
  OPC_Decode, 129, 8, 136, 1,                // 14457:     decode to VEXT2XV_DU_HU using decoder 136
                                             // 14457:    }
  15, 0,                                     // 14462:    case 0xf: {
  OPC_Decode, 130, 8, 136, 1,                // 14464:     decode to VEXT2XV_DU_WU using decoder 136
                                             // 14464:    }
                                             // 14464:    } // switch Inst[14:10]
                                             // 14464:   }
  7, 0,                                      // 14469:   case 0x7: {
  OPC_Decode, 235, 15, 134, 1,               // 14471:    decode to XVHSELI_D using decoder 134
                                             // 14471:   }
                                             // 14471:   } // switch Inst[17:15]
                                             // 14471:  }
  168, 1, 45,                                // 14476:  case 0xa8: {
  OPC_SwitchField, 16, 2,                    // 14479:   switch Inst[17:16] {
  0, 33,                                     // 14482:   case 0x0: {
  OPC_SwitchField, 15, 1,                    // 14484:    switch Inst[15] {
  0, 21,                                     // 14487:    case 0x0: {
  OPC_SwitchField, 14, 1,                    // 14489:     switch Inst[14] {
  0, 9,                                      // 14492:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 14494:      check Inst[13] == 0x1
  OPC_Decode, 177, 17, 139, 1,               // 14498:      decode to XVROTRI_B using decoder 139
                                             // 14498:     }
  1, 0,                                      // 14503:     case 0x1: {
  OPC_Decode, 179, 17, 140, 1,               // 14505:      decode to XVROTRI_H using decoder 140
                                             // 14505:     }
                                             // 14505:     } // switch Inst[14]
                                             // 14505:    }
  1, 0,                                      // 14510:    case 0x1: {
  OPC_Decode, 180, 17, 134, 1,               // 14512:     decode to XVROTRI_W using decoder 134
                                             // 14512:    }
                                             // 14512:    } // switch Inst[15]
                                             // 14512:   }
  1, 0,                                      // 14517:   case 0x1: {
  OPC_Decode, 178, 17, 141, 1,               // 14519:    decode to XVROTRI_D using decoder 141
                                             // 14519:   }
                                             // 14519:   } // switch Inst[17:16]
                                             // 14519:  }
  169, 1, 45,                                // 14524:  case 0xa9: {
  OPC_SwitchField, 16, 2,                    // 14527:   switch Inst[17:16] {
  0, 33,                                     // 14530:   case 0x0: {
  OPC_SwitchField, 15, 1,                    // 14532:    switch Inst[15] {
  0, 21,                                     // 14535:    case 0x0: {
  OPC_SwitchField, 14, 1,                    // 14537:     switch Inst[14] {
  0, 9,                                      // 14540:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 14542:      check Inst[13] == 0x1
  OPC_Decode, 190, 18, 139, 1,               // 14546:      decode to XVSRLRI_B using decoder 139
                                             // 14546:     }
  1, 0,                                      // 14551:     case 0x1: {
  OPC_Decode, 192, 18, 140, 1,               // 14553:      decode to XVSRLRI_H using decoder 140
                                             // 14553:     }
                                             // 14553:     } // switch Inst[14]
                                             // 14553:    }
  1, 0,                                      // 14558:    case 0x1: {
  OPC_Decode, 193, 18, 134, 1,               // 14560:     decode to XVSRLRI_W using decoder 134
                                             // 14560:    }
                                             // 14560:    } // switch Inst[15]
                                             // 14560:   }
  1, 0,                                      // 14565:   case 0x1: {
  OPC_Decode, 191, 18, 141, 1,               // 14567:    decode to XVSRLRI_D using decoder 141
                                             // 14567:   }
                                             // 14567:   } // switch Inst[17:16]
                                             // 14567:  }
  170, 1, 45,                                // 14572:  case 0xaa: {
  OPC_SwitchField, 16, 2,                    // 14575:   switch Inst[17:16] {
  0, 33,                                     // 14578:   case 0x0: {
  OPC_SwitchField, 15, 1,                    // 14580:    switch Inst[15] {
  0, 21,                                     // 14583:    case 0x0: {
  OPC_SwitchField, 14, 1,                    // 14585:     switch Inst[14] {
  0, 9,                                      // 14588:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 14590:      check Inst[13] == 0x1
  OPC_Decode, 160, 18, 139, 1,               // 14594:      decode to XVSRARI_B using decoder 139
                                             // 14594:     }
  1, 0,                                      // 14599:     case 0x1: {
  OPC_Decode, 162, 18, 140, 1,               // 14601:      decode to XVSRARI_H using decoder 140
                                             // 14601:     }
                                             // 14601:     } // switch Inst[14]
                                             // 14601:    }
  1, 0,                                      // 14606:    case 0x1: {
  OPC_Decode, 163, 18, 134, 1,               // 14608:     decode to XVSRARI_W using decoder 134
                                             // 14608:    }
                                             // 14608:    } // switch Inst[15]
                                             // 14608:   }
  1, 0,                                      // 14613:   case 0x1: {
  OPC_Decode, 161, 18, 141, 1,               // 14615:    decode to XVSRARI_D using decoder 141
                                             // 14615:   }
                                             // 14615:   } // switch Inst[17:16]
                                             // 14615:  }
  186, 1, 21,                                // 14620:  case 0xba: {
  OPC_SwitchField, 13, 5,                    // 14623:   switch Inst[17:13] {
  30, 5,                                     // 14626:   case 0x1e: {
  OPC_Decode, 253, 15, 142, 1,               // 14628:    decode to XVINSGR2VR_W using decoder 142
                                             // 14628:   }
  31, 0,                                     // 14633:   case 0x1f: {
  OPC_CheckField, 12, 1, 0,                  // 14635:    check Inst[12] == 0x0
  OPC_Decode, 252, 15, 143, 1,               // 14639:    decode to XVINSGR2VR_D using decoder 143
                                             // 14639:   }
                                             // 14639:   } // switch Inst[17:13]
                                             // 14639:  }
  187, 1, 21,                                // 14644:  case 0xbb: {
  OPC_SwitchField, 13, 5,                    // 14647:   switch Inst[17:13] {
  30, 5,                                     // 14650:   case 0x1e: {
  OPC_Decode, 156, 17, 144, 1,               // 14652:    decode to XVPICKVE2GR_W using decoder 144
                                             // 14652:   }
  31, 0,                                     // 14657:   case 0x1f: {
  OPC_CheckField, 12, 1, 0,                  // 14659:    check Inst[12] == 0x0
  OPC_Decode, 154, 17, 145, 1,               // 14663:    decode to XVPICKVE2GR_D using decoder 145
                                             // 14663:   }
                                             // 14663:   } // switch Inst[17:13]
                                             // 14663:  }
  188, 1, 21,                                // 14668:  case 0xbc: {
  OPC_SwitchField, 13, 5,                    // 14671:   switch Inst[17:13] {
  30, 5,                                     // 14674:   case 0x1e: {
  OPC_Decode, 157, 17, 144, 1,               // 14676:    decode to XVPICKVE2GR_WU using decoder 144
                                             // 14676:   }
  31, 0,                                     // 14681:   case 0x1f: {
  OPC_CheckField, 12, 1, 0,                  // 14683:    check Inst[12] == 0x0
  OPC_Decode, 155, 17, 145, 1,               // 14687:    decode to XVPICKVE2GR_DU using decoder 145
                                             // 14687:   }
                                             // 14687:   } // switch Inst[17:13]
                                             // 14687:  }
  189, 1, 45,                                // 14692:  case 0xbd: {
  OPC_SwitchField, 14, 4,                    // 14695:   switch Inst[17:14] {
  14, 5,                                     // 14698:   case 0xe: {
  OPC_Decode, 160, 17, 140, 1,               // 14700:    decode to XVREPL128VEI_B using decoder 140
                                             // 14700:   }
  15, 0,                                     // 14705:   case 0xf: {
  OPC_SwitchField, 13, 1,                    // 14707:    switch Inst[13] {
  0, 5,                                      // 14710:    case 0x0: {
  OPC_Decode, 162, 17, 139, 1,               // 14712:     decode to XVREPL128VEI_H using decoder 139
                                             // 14712:    }
  1, 0,                                      // 14717:    case 0x1: {
  OPC_SwitchField, 12, 1,                    // 14719:     switch Inst[12] {
  0, 5,                                      // 14722:     case 0x0: {
  OPC_Decode, 163, 17, 146, 1,               // 14724:      decode to XVREPL128VEI_W using decoder 146
                                             // 14724:     }
  1, 0,                                      // 14729:     case 0x1: {
  OPC_CheckField, 11, 1, 0,                  // 14731:      check Inst[11] == 0x0
  OPC_Decode, 161, 17, 147, 1,               // 14735:      decode to XVREPL128VEI_D using decoder 147
                                             // 14735:     }
                                             // 14735:     } // switch Inst[12]
                                             // 14735:    }
                                             // 14735:    } // switch Inst[13]
                                             // 14735:   }
                                             // 14735:   } // switch Inst[17:14]
                                             // 14735:  }
  191, 1, 21,                                // 14740:  case 0xbf: {
  OPC_SwitchField, 13, 5,                    // 14743:   switch Inst[17:13] {
  30, 5,                                     // 14746:   case 0x1e: {
  OPC_Decode, 255, 15, 148, 1,               // 14748:    decode to XVINSVE0_W using decoder 148
                                             // 14748:   }
  31, 0,                                     // 14753:   case 0x1f: {
  OPC_CheckField, 12, 1, 0,                  // 14755:    check Inst[12] == 0x0
  OPC_Decode, 254, 15, 149, 1,               // 14759:    decode to XVINSVE0_D using decoder 149
                                             // 14759:   }
                                             // 14759:   } // switch Inst[17:13]
                                             // 14759:  }
  192, 1, 21,                                // 14764:  case 0xc0: {
  OPC_SwitchField, 13, 5,                    // 14767:   switch Inst[17:13] {
  30, 5,                                     // 14770:   case 0x1e: {
  OPC_Decode, 159, 17, 139, 1,               // 14772:    decode to XVPICKVE_W using decoder 139
                                             // 14772:   }
  31, 0,                                     // 14777:   case 0x1f: {
  OPC_CheckField, 12, 1, 0,                  // 14779:    check Inst[12] == 0x0
  OPC_Decode, 158, 17, 146, 1,               // 14783:    decode to XVPICKVE_D using decoder 146
                                             // 14783:   }
                                             // 14783:   } // switch Inst[17:13]
                                             // 14783:  }
  193, 1, 43,                                // 14788:  case 0xc1: {
  OPC_SwitchField, 10, 8,                    // 14791:   switch Inst[17:10] {
  192, 1, 5,                                 // 14794:   case 0xc0: {
  OPC_Decode, 168, 17, 136, 1,               // 14797:    decode to XVREPLVE0_B using decoder 136
                                             // 14797:   }
  224, 1, 5,                                 // 14802:   case 0xe0: {
  OPC_Decode, 170, 17, 136, 1,               // 14805:    decode to XVREPLVE0_H using decoder 136
                                             // 14805:   }
  240, 1, 5,                                 // 14810:   case 0xf0: {
  OPC_Decode, 172, 17, 136, 1,               // 14813:    decode to XVREPLVE0_W using decoder 136
                                             // 14813:   }
  248, 1, 5,                                 // 14818:   case 0xf8: {
  OPC_Decode, 169, 17, 136, 1,               // 14821:    decode to XVREPLVE0_D using decoder 136
                                             // 14821:   }
  252, 1, 0,                                 // 14826:   case 0xfc: {
  OPC_Decode, 171, 17, 136, 1,               // 14829:    decode to XVREPLVE0_Q using decoder 136
                                             // 14829:   }
                                             // 14829:   } // switch Inst[17:10]
                                             // 14829:  }
  194, 1, 44,                                // 14834:  case 0xc2: {
  OPC_SwitchField, 15, 3,                    // 14837:   switch Inst[17:15] {
  0, 21,                                     // 14840:   case 0x0: {
  OPC_SwitchField, 14, 1,                    // 14842:    switch Inst[14] {
  0, 9,                                      // 14845:    case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 14847:     check Inst[13] == 0x1
  OPC_Decode, 254, 17, 139, 1,               // 14851:     decode to XVSLLWIL_H_B using decoder 139
                                             // 14851:    }
  1, 0,                                      // 14856:    case 0x1: {
  OPC_Decode, 128, 18, 140, 1,               // 14858:     decode to XVSLLWIL_W_H using decoder 140
                                             // 14858:    }
                                             // 14858:    } // switch Inst[14]
                                             // 14858:   }
  1, 5,                                      // 14863:   case 0x1: {
  OPC_Decode, 252, 17, 134, 1,               // 14865:    decode to XVSLLWIL_D_W using decoder 134
                                             // 14865:   }
  2, 0,                                      // 14870:   case 0x2: {
  OPC_CheckField, 10, 5, 0,                  // 14872:    check Inst[14:10] == 0x0
  OPC_Decode, 212, 14, 136, 1,               // 14876:    decode to XVEXTL_Q_D using decoder 136
                                             // 14876:   }
                                             // 14876:   } // switch Inst[17:15]
                                             // 14876:  }
  195, 1, 44,                                // 14881:  case 0xc3: {
  OPC_SwitchField, 15, 3,                    // 14884:   switch Inst[17:15] {
  0, 21,                                     // 14887:   case 0x0: {
  OPC_SwitchField, 14, 1,                    // 14889:    switch Inst[14] {
  0, 9,                                      // 14892:    case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 14894:     check Inst[13] == 0x1
  OPC_Decode, 253, 17, 139, 1,               // 14898:     decode to XVSLLWIL_HU_BU using decoder 139
                                             // 14898:    }
  1, 0,                                      // 14903:    case 0x1: {
  OPC_Decode, 255, 17, 140, 1,               // 14905:     decode to XVSLLWIL_WU_HU using decoder 140
                                             // 14905:    }
                                             // 14905:    } // switch Inst[14]
                                             // 14905:   }
  1, 5,                                      // 14910:   case 0x1: {
  OPC_Decode, 251, 17, 134, 1,               // 14912:    decode to XVSLLWIL_DU_WU using decoder 134
                                             // 14912:   }
  2, 0,                                      // 14917:   case 0x2: {
  OPC_CheckField, 10, 5, 0,                  // 14919:    check Inst[14:10] == 0x0
  OPC_Decode, 211, 14, 136, 1,               // 14923:    decode to XVEXTL_QU_DU using decoder 136
                                             // 14923:   }
                                             // 14923:   } // switch Inst[17:15]
                                             // 14923:  }
  196, 1, 45,                                // 14928:  case 0xc4: {
  OPC_SwitchField, 16, 2,                    // 14931:   switch Inst[17:16] {
  0, 33,                                     // 14934:   case 0x0: {
  OPC_SwitchField, 15, 1,                    // 14936:    switch Inst[15] {
  0, 21,                                     // 14939:    case 0x0: {
  OPC_SwitchField, 14, 1,                    // 14941:     switch Inst[14] {
  0, 9,                                      // 14944:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 14946:      check Inst[13] == 0x1
  OPC_Decode, 159, 14, 139, 1,               // 14950:      decode to XVBITCLRI_B using decoder 139
                                             // 14950:     }
  1, 0,                                      // 14955:     case 0x1: {
  OPC_Decode, 161, 14, 140, 1,               // 14957:      decode to XVBITCLRI_H using decoder 140
                                             // 14957:     }
                                             // 14957:     } // switch Inst[14]
                                             // 14957:    }
  1, 0,                                      // 14962:    case 0x1: {
  OPC_Decode, 162, 14, 134, 1,               // 14964:     decode to XVBITCLRI_W using decoder 134
                                             // 14964:    }
                                             // 14964:    } // switch Inst[15]
                                             // 14964:   }
  1, 0,                                      // 14969:   case 0x1: {
  OPC_Decode, 160, 14, 141, 1,               // 14971:    decode to XVBITCLRI_D using decoder 141
                                             // 14971:   }
                                             // 14971:   } // switch Inst[17:16]
                                             // 14971:  }
  197, 1, 45,                                // 14976:  case 0xc5: {
  OPC_SwitchField, 16, 2,                    // 14979:   switch Inst[17:16] {
  0, 33,                                     // 14982:   case 0x0: {
  OPC_SwitchField, 15, 1,                    // 14984:    switch Inst[15] {
  0, 21,                                     // 14987:    case 0x0: {
  OPC_SwitchField, 14, 1,                    // 14989:     switch Inst[14] {
  0, 9,                                      // 14992:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 14994:      check Inst[13] == 0x1
  OPC_Decode, 177, 14, 139, 1,               // 14998:      decode to XVBITSETI_B using decoder 139
                                             // 14998:     }
  1, 0,                                      // 15003:     case 0x1: {
  OPC_Decode, 179, 14, 140, 1,               // 15005:      decode to XVBITSETI_H using decoder 140
                                             // 15005:     }
                                             // 15005:     } // switch Inst[14]
                                             // 15005:    }
  1, 0,                                      // 15010:    case 0x1: {
  OPC_Decode, 180, 14, 134, 1,               // 15012:     decode to XVBITSETI_W using decoder 134
                                             // 15012:    }
                                             // 15012:    } // switch Inst[15]
                                             // 15012:   }
  1, 0,                                      // 15017:   case 0x1: {
  OPC_Decode, 178, 14, 141, 1,               // 15019:    decode to XVBITSETI_D using decoder 141
                                             // 15019:   }
                                             // 15019:   } // switch Inst[17:16]
                                             // 15019:  }
  198, 1, 45,                                // 15024:  case 0xc6: {
  OPC_SwitchField, 16, 2,                    // 15027:   switch Inst[17:16] {
  0, 33,                                     // 15030:   case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15032:    switch Inst[15] {
  0, 21,                                     // 15035:    case 0x0: {
  OPC_SwitchField, 14, 1,                    // 15037:     switch Inst[14] {
  0, 9,                                      // 15040:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 15042:      check Inst[13] == 0x1
  OPC_Decode, 167, 14, 139, 1,               // 15046:      decode to XVBITREVI_B using decoder 139
                                             // 15046:     }
  1, 0,                                      // 15051:     case 0x1: {
  OPC_Decode, 169, 14, 140, 1,               // 15053:      decode to XVBITREVI_H using decoder 140
                                             // 15053:     }
                                             // 15053:     } // switch Inst[14]
                                             // 15053:    }
  1, 0,                                      // 15058:    case 0x1: {
  OPC_Decode, 170, 14, 134, 1,               // 15060:     decode to XVBITREVI_W using decoder 134
                                             // 15060:    }
                                             // 15060:    } // switch Inst[15]
                                             // 15060:   }
  1, 0,                                      // 15065:   case 0x1: {
  OPC_Decode, 168, 14, 141, 1,               // 15067:    decode to XVBITREVI_D using decoder 141
                                             // 15067:   }
                                             // 15067:   } // switch Inst[17:16]
                                             // 15067:  }
  201, 1, 45,                                // 15072:  case 0xc9: {
  OPC_SwitchField, 16, 2,                    // 15075:   switch Inst[17:16] {
  0, 33,                                     // 15078:   case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15080:    switch Inst[15] {
  0, 21,                                     // 15083:    case 0x0: {
  OPC_SwitchField, 14, 1,                    // 15085:     switch Inst[14] {
  0, 9,                                      // 15088:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 15090:      check Inst[13] == 0x1
  OPC_Decode, 193, 17, 139, 1,               // 15094:      decode to XVSAT_B using decoder 139
                                             // 15094:     }
  1, 0,                                      // 15099:     case 0x1: {
  OPC_Decode, 197, 17, 140, 1,               // 15101:      decode to XVSAT_H using decoder 140
                                             // 15101:     }
                                             // 15101:     } // switch Inst[14]
                                             // 15101:    }
  1, 0,                                      // 15106:    case 0x1: {
  OPC_Decode, 199, 17, 134, 1,               // 15108:     decode to XVSAT_W using decoder 134
                                             // 15108:    }
                                             // 15108:    } // switch Inst[15]
                                             // 15108:   }
  1, 0,                                      // 15113:   case 0x1: {
  OPC_Decode, 195, 17, 141, 1,               // 15115:    decode to XVSAT_D using decoder 141
                                             // 15115:   }
                                             // 15115:   } // switch Inst[17:16]
                                             // 15115:  }
  202, 1, 45,                                // 15120:  case 0xca: {
  OPC_SwitchField, 16, 2,                    // 15123:   switch Inst[17:16] {
  0, 33,                                     // 15126:   case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15128:    switch Inst[15] {
  0, 21,                                     // 15131:    case 0x0: {
  OPC_SwitchField, 14, 1,                    // 15133:     switch Inst[14] {
  0, 9,                                      // 15136:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 15138:      check Inst[13] == 0x1
  OPC_Decode, 194, 17, 139, 1,               // 15142:      decode to XVSAT_BU using decoder 139
                                             // 15142:     }
  1, 0,                                      // 15147:     case 0x1: {
  OPC_Decode, 198, 17, 140, 1,               // 15149:      decode to XVSAT_HU using decoder 140
                                             // 15149:     }
                                             // 15149:     } // switch Inst[14]
                                             // 15149:    }
  1, 0,                                      // 15154:    case 0x1: {
  OPC_Decode, 200, 17, 134, 1,               // 15156:     decode to XVSAT_WU using decoder 134
                                             // 15156:    }
                                             // 15156:    } // switch Inst[15]
                                             // 15156:   }
  1, 0,                                      // 15161:   case 0x1: {
  OPC_Decode, 196, 17, 141, 1,               // 15163:    decode to XVSAT_DU using decoder 141
                                             // 15163:   }
                                             // 15163:   } // switch Inst[17:16]
                                             // 15163:  }
  203, 1, 45,                                // 15168:  case 0xcb: {
  OPC_SwitchField, 16, 2,                    // 15171:   switch Inst[17:16] {
  0, 33,                                     // 15174:   case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15176:    switch Inst[15] {
  0, 21,                                     // 15179:    case 0x0: {
  OPC_SwitchField, 14, 1,                    // 15181:     switch Inst[14] {
  0, 9,                                      // 15184:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 15186:      check Inst[13] == 0x1
  OPC_Decode, 247, 17, 139, 1,               // 15190:      decode to XVSLLI_B using decoder 139
                                             // 15190:     }
  1, 0,                                      // 15195:     case 0x1: {
  OPC_Decode, 249, 17, 140, 1,               // 15197:      decode to XVSLLI_H using decoder 140
                                             // 15197:     }
                                             // 15197:     } // switch Inst[14]
                                             // 15197:    }
  1, 0,                                      // 15202:    case 0x1: {
  OPC_Decode, 250, 17, 134, 1,               // 15204:     decode to XVSLLI_W using decoder 134
                                             // 15204:    }
                                             // 15204:    } // switch Inst[15]
                                             // 15204:   }
  1, 0,                                      // 15209:   case 0x1: {
  OPC_Decode, 248, 17, 141, 1,               // 15211:    decode to XVSLLI_D using decoder 141
                                             // 15211:   }
                                             // 15211:   } // switch Inst[17:16]
                                             // 15211:  }
  204, 1, 45,                                // 15216:  case 0xcc: {
  OPC_SwitchField, 16, 2,                    // 15219:   switch Inst[17:16] {
  0, 33,                                     // 15222:   case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15224:    switch Inst[15] {
  0, 21,                                     // 15227:    case 0x0: {
  OPC_SwitchField, 14, 1,                    // 15229:     switch Inst[14] {
  0, 9,                                      // 15232:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 15234:      check Inst[13] == 0x1
  OPC_Decode, 179, 18, 139, 1,               // 15238:      decode to XVSRLI_B using decoder 139
                                             // 15238:     }
  1, 0,                                      // 15243:     case 0x1: {
  OPC_Decode, 181, 18, 140, 1,               // 15245:      decode to XVSRLI_H using decoder 140
                                             // 15245:     }
                                             // 15245:     } // switch Inst[14]
                                             // 15245:    }
  1, 0,                                      // 15250:    case 0x1: {
  OPC_Decode, 182, 18, 134, 1,               // 15252:     decode to XVSRLI_W using decoder 134
                                             // 15252:    }
                                             // 15252:    } // switch Inst[15]
                                             // 15252:   }
  1, 0,                                      // 15257:   case 0x1: {
  OPC_Decode, 180, 18, 141, 1,               // 15259:    decode to XVSRLI_D using decoder 141
                                             // 15259:   }
                                             // 15259:   } // switch Inst[17:16]
                                             // 15259:  }
  205, 1, 45,                                // 15264:  case 0xcd: {
  OPC_SwitchField, 16, 2,                    // 15267:   switch Inst[17:16] {
  0, 33,                                     // 15270:   case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15272:    switch Inst[15] {
  0, 21,                                     // 15275:    case 0x0: {
  OPC_SwitchField, 14, 1,                    // 15277:     switch Inst[14] {
  0, 9,                                      // 15280:     case 0x0: {
  OPC_CheckField, 13, 1, 1,                  // 15282:      check Inst[13] == 0x1
  OPC_Decode, 149, 18, 139, 1,               // 15286:      decode to XVSRAI_B using decoder 139
                                             // 15286:     }
  1, 0,                                      // 15291:     case 0x1: {
  OPC_Decode, 151, 18, 140, 1,               // 15293:      decode to XVSRAI_H using decoder 140
                                             // 15293:     }
                                             // 15293:     } // switch Inst[14]
                                             // 15293:    }
  1, 0,                                      // 15298:    case 0x1: {
  OPC_Decode, 152, 18, 134, 1,               // 15300:     decode to XVSRAI_W using decoder 134
                                             // 15300:    }
                                             // 15300:    } // switch Inst[15]
                                             // 15300:   }
  1, 0,                                      // 15305:   case 0x1: {
  OPC_Decode, 150, 18, 141, 1,               // 15307:    decode to XVSRAI_D using decoder 141
                                             // 15307:   }
                                             // 15307:   } // switch Inst[17:16]
                                             // 15307:  }
  208, 1, 45,                                // 15312:  case 0xd0: {
  OPC_SwitchField, 17, 1,                    // 15315:   switch Inst[17] {
  0, 33,                                     // 15318:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15320:    switch Inst[16] {
  0, 21,                                     // 15323:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15325:     switch Inst[15] {
  0, 9,                                      // 15328:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15330:      check Inst[14] == 0x1
  OPC_Decode, 183, 18, 150, 1,               // 15334:      decode to XVSRLNI_B_H using decoder 150
                                             // 15334:     }
  1, 0,                                      // 15339:     case 0x1: {
  OPC_Decode, 185, 18, 135, 1,               // 15341:      decode to XVSRLNI_H_W using decoder 135
                                             // 15341:     }
                                             // 15341:     } // switch Inst[15]
                                             // 15341:    }
  1, 0,                                      // 15346:    case 0x1: {
  OPC_Decode, 186, 18, 151, 1,               // 15348:     decode to XVSRLNI_W_D using decoder 151
                                             // 15348:    }
                                             // 15348:    } // switch Inst[16]
                                             // 15348:   }
  1, 0,                                      // 15353:   case 0x1: {
  OPC_Decode, 184, 18, 152, 1,               // 15355:    decode to XVSRLNI_D_Q using decoder 152
                                             // 15355:   }
                                             // 15355:   } // switch Inst[17]
                                             // 15355:  }
  209, 1, 45,                                // 15360:  case 0xd1: {
  OPC_SwitchField, 17, 1,                    // 15363:   switch Inst[17] {
  0, 33,                                     // 15366:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15368:    switch Inst[16] {
  0, 21,                                     // 15371:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15373:     switch Inst[15] {
  0, 9,                                      // 15376:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15378:      check Inst[14] == 0x1
  OPC_Decode, 194, 18, 150, 1,               // 15382:      decode to XVSRLRNI_B_H using decoder 150
                                             // 15382:     }
  1, 0,                                      // 15387:     case 0x1: {
  OPC_Decode, 196, 18, 135, 1,               // 15389:      decode to XVSRLRNI_H_W using decoder 135
                                             // 15389:     }
                                             // 15389:     } // switch Inst[15]
                                             // 15389:    }
  1, 0,                                      // 15394:    case 0x1: {
  OPC_Decode, 197, 18, 151, 1,               // 15396:     decode to XVSRLRNI_W_D using decoder 151
                                             // 15396:    }
                                             // 15396:    } // switch Inst[16]
                                             // 15396:   }
  1, 0,                                      // 15401:   case 0x1: {
  OPC_Decode, 195, 18, 152, 1,               // 15403:    decode to XVSRLRNI_D_Q using decoder 152
                                             // 15403:   }
                                             // 15403:   } // switch Inst[17]
                                             // 15403:  }
  210, 1, 45,                                // 15408:  case 0xd2: {
  OPC_SwitchField, 17, 1,                    // 15411:   switch Inst[17] {
  0, 33,                                     // 15414:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15416:    switch Inst[16] {
  0, 21,                                     // 15419:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15421:     switch Inst[15] {
  0, 9,                                      // 15424:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15426:      check Inst[14] == 0x1
  OPC_Decode, 238, 18, 150, 1,               // 15430:      decode to XVSSRLNI_B_H using decoder 150
                                             // 15430:     }
  1, 0,                                      // 15435:     case 0x1: {
  OPC_Decode, 242, 18, 135, 1,               // 15437:      decode to XVSSRLNI_H_W using decoder 135
                                             // 15437:     }
                                             // 15437:     } // switch Inst[15]
                                             // 15437:    }
  1, 0,                                      // 15442:    case 0x1: {
  OPC_Decode, 244, 18, 151, 1,               // 15444:     decode to XVSSRLNI_W_D using decoder 151
                                             // 15444:    }
                                             // 15444:    } // switch Inst[16]
                                             // 15444:   }
  1, 0,                                      // 15449:   case 0x1: {
  OPC_Decode, 240, 18, 152, 1,               // 15451:    decode to XVSSRLNI_D_Q using decoder 152
                                             // 15451:   }
                                             // 15451:   } // switch Inst[17]
                                             // 15451:  }
  211, 1, 45,                                // 15456:  case 0xd3: {
  OPC_SwitchField, 17, 1,                    // 15459:   switch Inst[17] {
  0, 33,                                     // 15462:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15464:    switch Inst[16] {
  0, 21,                                     // 15467:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15469:     switch Inst[15] {
  0, 9,                                      // 15472:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15474:      check Inst[14] == 0x1
  OPC_Decode, 237, 18, 150, 1,               // 15478:      decode to XVSSRLNI_BU_H using decoder 150
                                             // 15478:     }
  1, 0,                                      // 15483:     case 0x1: {
  OPC_Decode, 241, 18, 135, 1,               // 15485:      decode to XVSSRLNI_HU_W using decoder 135
                                             // 15485:     }
                                             // 15485:     } // switch Inst[15]
                                             // 15485:    }
  1, 0,                                      // 15490:    case 0x1: {
  OPC_Decode, 243, 18, 151, 1,               // 15492:     decode to XVSSRLNI_WU_D using decoder 151
                                             // 15492:    }
                                             // 15492:    } // switch Inst[16]
                                             // 15492:   }
  1, 0,                                      // 15497:   case 0x1: {
  OPC_Decode, 239, 18, 152, 1,               // 15499:    decode to XVSSRLNI_DU_Q using decoder 152
                                             // 15499:   }
                                             // 15499:   } // switch Inst[17]
                                             // 15499:  }
  212, 1, 45,                                // 15504:  case 0xd4: {
  OPC_SwitchField, 17, 1,                    // 15507:   switch Inst[17] {
  0, 33,                                     // 15510:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15512:    switch Inst[16] {
  0, 21,                                     // 15515:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15517:     switch Inst[15] {
  0, 9,                                      // 15520:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15522:      check Inst[14] == 0x1
  OPC_Decode, 252, 18, 150, 1,               // 15526:      decode to XVSSRLRNI_B_H using decoder 150
                                             // 15526:     }
  1, 0,                                      // 15531:     case 0x1: {
  OPC_Decode, 128, 19, 135, 1,               // 15533:      decode to XVSSRLRNI_H_W using decoder 135
                                             // 15533:     }
                                             // 15533:     } // switch Inst[15]
                                             // 15533:    }
  1, 0,                                      // 15538:    case 0x1: {
  OPC_Decode, 130, 19, 151, 1,               // 15540:     decode to XVSSRLRNI_W_D using decoder 151
                                             // 15540:    }
                                             // 15540:    } // switch Inst[16]
                                             // 15540:   }
  1, 0,                                      // 15545:   case 0x1: {
  OPC_Decode, 254, 18, 152, 1,               // 15547:    decode to XVSSRLRNI_D_Q using decoder 152
                                             // 15547:   }
                                             // 15547:   } // switch Inst[17]
                                             // 15547:  }
  213, 1, 45,                                // 15552:  case 0xd5: {
  OPC_SwitchField, 17, 1,                    // 15555:   switch Inst[17] {
  0, 33,                                     // 15558:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15560:    switch Inst[16] {
  0, 21,                                     // 15563:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15565:     switch Inst[15] {
  0, 9,                                      // 15568:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15570:      check Inst[14] == 0x1
  OPC_Decode, 251, 18, 150, 1,               // 15574:      decode to XVSSRLRNI_BU_H using decoder 150
                                             // 15574:     }
  1, 0,                                      // 15579:     case 0x1: {
  OPC_Decode, 255, 18, 135, 1,               // 15581:      decode to XVSSRLRNI_HU_W using decoder 135
                                             // 15581:     }
                                             // 15581:     } // switch Inst[15]
                                             // 15581:    }
  1, 0,                                      // 15586:    case 0x1: {
  OPC_Decode, 129, 19, 151, 1,               // 15588:     decode to XVSSRLRNI_WU_D using decoder 151
                                             // 15588:    }
                                             // 15588:    } // switch Inst[16]
                                             // 15588:   }
  1, 0,                                      // 15593:   case 0x1: {
  OPC_Decode, 253, 18, 152, 1,               // 15595:    decode to XVSSRLRNI_DU_Q using decoder 152
                                             // 15595:   }
                                             // 15595:   } // switch Inst[17]
                                             // 15595:  }
  214, 1, 45,                                // 15600:  case 0xd6: {
  OPC_SwitchField, 17, 1,                    // 15603:   switch Inst[17] {
  0, 33,                                     // 15606:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15608:    switch Inst[16] {
  0, 21,                                     // 15611:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15613:     switch Inst[15] {
  0, 9,                                      // 15616:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15618:      check Inst[14] == 0x1
  OPC_Decode, 153, 18, 150, 1,               // 15622:      decode to XVSRANI_B_H using decoder 150
                                             // 15622:     }
  1, 0,                                      // 15627:     case 0x1: {
  OPC_Decode, 155, 18, 135, 1,               // 15629:      decode to XVSRANI_H_W using decoder 135
                                             // 15629:     }
                                             // 15629:     } // switch Inst[15]
                                             // 15629:    }
  1, 0,                                      // 15634:    case 0x1: {
  OPC_Decode, 156, 18, 151, 1,               // 15636:     decode to XVSRANI_W_D using decoder 151
                                             // 15636:    }
                                             // 15636:    } // switch Inst[16]
                                             // 15636:   }
  1, 0,                                      // 15641:   case 0x1: {
  OPC_Decode, 154, 18, 152, 1,               // 15643:    decode to XVSRANI_D_Q using decoder 152
                                             // 15643:   }
                                             // 15643:   } // switch Inst[17]
                                             // 15643:  }
  215, 1, 45,                                // 15648:  case 0xd7: {
  OPC_SwitchField, 17, 1,                    // 15651:   switch Inst[17] {
  0, 33,                                     // 15654:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15656:    switch Inst[16] {
  0, 21,                                     // 15659:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15661:     switch Inst[15] {
  0, 9,                                      // 15664:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15666:      check Inst[14] == 0x1
  OPC_Decode, 164, 18, 150, 1,               // 15670:      decode to XVSRARNI_B_H using decoder 150
                                             // 15670:     }
  1, 0,                                      // 15675:     case 0x1: {
  OPC_Decode, 166, 18, 135, 1,               // 15677:      decode to XVSRARNI_H_W using decoder 135
                                             // 15677:     }
                                             // 15677:     } // switch Inst[15]
                                             // 15677:    }
  1, 0,                                      // 15682:    case 0x1: {
  OPC_Decode, 167, 18, 151, 1,               // 15684:     decode to XVSRARNI_W_D using decoder 151
                                             // 15684:    }
                                             // 15684:    } // switch Inst[16]
                                             // 15684:   }
  1, 0,                                      // 15689:   case 0x1: {
  OPC_Decode, 165, 18, 152, 1,               // 15691:    decode to XVSRARNI_D_Q using decoder 152
                                             // 15691:   }
                                             // 15691:   } // switch Inst[17]
                                             // 15691:  }
  216, 1, 45,                                // 15696:  case 0xd8: {
  OPC_SwitchField, 17, 1,                    // 15699:   switch Inst[17] {
  0, 33,                                     // 15702:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15704:    switch Inst[16] {
  0, 21,                                     // 15707:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15709:     switch Inst[15] {
  0, 9,                                      // 15712:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15714:      check Inst[14] == 0x1
  OPC_Decode, 210, 18, 150, 1,               // 15718:      decode to XVSSRANI_B_H using decoder 150
                                             // 15718:     }
  1, 0,                                      // 15723:     case 0x1: {
  OPC_Decode, 214, 18, 135, 1,               // 15725:      decode to XVSSRANI_H_W using decoder 135
                                             // 15725:     }
                                             // 15725:     } // switch Inst[15]
                                             // 15725:    }
  1, 0,                                      // 15730:    case 0x1: {
  OPC_Decode, 216, 18, 151, 1,               // 15732:     decode to XVSSRANI_W_D using decoder 151
                                             // 15732:    }
                                             // 15732:    } // switch Inst[16]
                                             // 15732:   }
  1, 0,                                      // 15737:   case 0x1: {
  OPC_Decode, 212, 18, 152, 1,               // 15739:    decode to XVSSRANI_D_Q using decoder 152
                                             // 15739:   }
                                             // 15739:   } // switch Inst[17]
                                             // 15739:  }
  217, 1, 45,                                // 15744:  case 0xd9: {
  OPC_SwitchField, 17, 1,                    // 15747:   switch Inst[17] {
  0, 33,                                     // 15750:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15752:    switch Inst[16] {
  0, 21,                                     // 15755:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15757:     switch Inst[15] {
  0, 9,                                      // 15760:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15762:      check Inst[14] == 0x1
  OPC_Decode, 209, 18, 150, 1,               // 15766:      decode to XVSSRANI_BU_H using decoder 150
                                             // 15766:     }
  1, 0,                                      // 15771:     case 0x1: {
  OPC_Decode, 213, 18, 135, 1,               // 15773:      decode to XVSSRANI_HU_W using decoder 135
                                             // 15773:     }
                                             // 15773:     } // switch Inst[15]
                                             // 15773:    }
  1, 0,                                      // 15778:    case 0x1: {
  OPC_Decode, 215, 18, 151, 1,               // 15780:     decode to XVSSRANI_WU_D using decoder 151
                                             // 15780:    }
                                             // 15780:    } // switch Inst[16]
                                             // 15780:   }
  1, 0,                                      // 15785:   case 0x1: {
  OPC_Decode, 211, 18, 152, 1,               // 15787:    decode to XVSSRANI_DU_Q using decoder 152
                                             // 15787:   }
                                             // 15787:   } // switch Inst[17]
                                             // 15787:  }
  218, 1, 45,                                // 15792:  case 0xda: {
  OPC_SwitchField, 17, 1,                    // 15795:   switch Inst[17] {
  0, 33,                                     // 15798:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15800:    switch Inst[16] {
  0, 21,                                     // 15803:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15805:     switch Inst[15] {
  0, 9,                                      // 15808:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15810:      check Inst[14] == 0x1
  OPC_Decode, 224, 18, 150, 1,               // 15814:      decode to XVSSRARNI_B_H using decoder 150
                                             // 15814:     }
  1, 0,                                      // 15819:     case 0x1: {
  OPC_Decode, 228, 18, 135, 1,               // 15821:      decode to XVSSRARNI_H_W using decoder 135
                                             // 15821:     }
                                             // 15821:     } // switch Inst[15]
                                             // 15821:    }
  1, 0,                                      // 15826:    case 0x1: {
  OPC_Decode, 230, 18, 151, 1,               // 15828:     decode to XVSSRARNI_W_D using decoder 151
                                             // 15828:    }
                                             // 15828:    } // switch Inst[16]
                                             // 15828:   }
  1, 0,                                      // 15833:   case 0x1: {
  OPC_Decode, 226, 18, 152, 1,               // 15835:    decode to XVSSRARNI_D_Q using decoder 152
                                             // 15835:   }
                                             // 15835:   } // switch Inst[17]
                                             // 15835:  }
  219, 1, 45,                                // 15840:  case 0xdb: {
  OPC_SwitchField, 17, 1,                    // 15843:   switch Inst[17] {
  0, 33,                                     // 15846:   case 0x0: {
  OPC_SwitchField, 16, 1,                    // 15848:    switch Inst[16] {
  0, 21,                                     // 15851:    case 0x0: {
  OPC_SwitchField, 15, 1,                    // 15853:     switch Inst[15] {
  0, 9,                                      // 15856:     case 0x0: {
  OPC_CheckField, 14, 1, 1,                  // 15858:      check Inst[14] == 0x1
  OPC_Decode, 223, 18, 150, 1,               // 15862:      decode to XVSSRARNI_BU_H using decoder 150
                                             // 15862:     }
  1, 0,                                      // 15867:     case 0x1: {
  OPC_Decode, 227, 18, 135, 1,               // 15869:      decode to XVSSRARNI_HU_W using decoder 135
                                             // 15869:     }
                                             // 15869:     } // switch Inst[15]
                                             // 15869:    }
  1, 0,                                      // 15874:    case 0x1: {
  OPC_Decode, 229, 18, 151, 1,               // 15876:     decode to XVSSRARNI_WU_D using decoder 151
                                             // 15876:    }
                                             // 15876:    } // switch Inst[16]
                                             // 15876:   }
  1, 0,                                      // 15881:   case 0x1: {
  OPC_Decode, 225, 18, 152, 1,               // 15883:    decode to XVSSRARNI_DU_Q using decoder 152
                                             // 15883:   }
                                             // 15883:   } // switch Inst[17]
                                             // 15883:  }
  224, 1, 5,                                 // 15888:  case 0xe0: {
  OPC_Decode, 214, 14, 153, 1,               // 15891:   decode to XVEXTRINS_D using decoder 153
                                             // 15891:  }
  225, 1, 5,                                 // 15896:  case 0xe1: {
  OPC_Decode, 216, 14, 153, 1,               // 15899:   decode to XVEXTRINS_W using decoder 153
                                             // 15899:  }
  226, 1, 5,                                 // 15904:  case 0xe2: {
  OPC_Decode, 215, 14, 153, 1,               // 15907:   decode to XVEXTRINS_H using decoder 153
                                             // 15907:  }
  227, 1, 5,                                 // 15912:  case 0xe3: {
  OPC_Decode, 213, 14, 153, 1,               // 15915:   decode to XVEXTRINS_B using decoder 153
                                             // 15915:  }
  228, 1, 5,                                 // 15920:  case 0xe4: {
  OPC_Decode, 219, 17, 154, 1,               // 15923:   decode to XVSHUF4I_B using decoder 154
                                             // 15923:  }
  229, 1, 5,                                 // 15928:  case 0xe5: {
  OPC_Decode, 221, 17, 154, 1,               // 15931:   decode to XVSHUF4I_H using decoder 154
                                             // 15931:  }
  230, 1, 5,                                 // 15936:  case 0xe6: {
  OPC_Decode, 222, 17, 154, 1,               // 15939:   decode to XVSHUF4I_W using decoder 154
                                             // 15939:  }
  231, 1, 5,                                 // 15944:  case 0xe7: {
  OPC_Decode, 220, 17, 153, 1,               // 15947:   decode to XVSHUF4I_D using decoder 153
                                             // 15947:  }
  241, 1, 5,                                 // 15952:  case 0xf1: {
  OPC_Decode, 175, 14, 153, 1,               // 15955:   decode to XVBITSELI_B using decoder 153
                                             // 15955:  }
  244, 1, 5,                                 // 15960:  case 0xf4: {
  OPC_Decode, 140, 14, 154, 1,               // 15963:   decode to XVANDI_B using decoder 154
                                             // 15963:  }
  245, 1, 5,                                 // 15968:  case 0xf5: {
  OPC_Decode, 255, 16, 154, 1,               // 15971:   decode to XVORI_B using decoder 154
                                             // 15971:  }
  246, 1, 5,                                 // 15976:  case 0xf6: {
  OPC_Decode, 176, 19, 154, 1,               // 15979:   decode to XVXORI_B using decoder 154
                                             // 15979:  }
  247, 1, 5,                                 // 15984:  case 0xf7: {
  OPC_Decode, 253, 16, 154, 1,               // 15987:   decode to XVNORI_B using decoder 154
                                             // 15987:  }
  248, 1, 5,                                 // 15992:  case 0xf8: {
  OPC_Decode, 129, 16, 155, 1,               // 15995:   decode to XVLDI using decoder 155
                                             // 15995:  }
  249, 1, 5,                                 // 16000:  case 0xf9: {
  OPC_Decode, 144, 17, 153, 1,               // 16003:   decode to XVPERMI_W using decoder 153
                                             // 16003:  }
  250, 1, 5,                                 // 16008:  case 0xfa: {
  OPC_Decode, 142, 17, 154, 1,               // 16011:   decode to XVPERMI_D using decoder 154
                                             // 16011:  }
  251, 1, 0,                                 // 16016:  case 0xfb: {
  OPC_Decode, 143, 17, 153, 1,               // 16019:   decode to XVPERMI_Q using decoder 153
                                             // 16019:  }
                                             // 16019:  } // switch Inst[25:18]
                                             // 16019: }
                                             // 16019: } // switch Inst[31:26]
};
// Handling 156 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, 2);
    if (!Check(S, DecodeSCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 1:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 2);
    if (!Check(S, DecodeSCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 2:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 3:
    tmp = fieldFromInstruction(insn, 5, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 4:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 5:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 6:
    return S;
  case 7:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 8:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 15, 2);
    if (!Check(S, decodeUImmOperand<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 9:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 15, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 10:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 15, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 11:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 12:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 13:
    tmp = fieldFromInstruction(insn, 0, 15);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 14:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 15:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 16:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 17:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 0, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 18:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 19:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 20:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 21:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 22:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 23:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 24:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 25:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 10, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 26:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 27:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 10, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 28:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 10, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 29:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 10, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 30:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 16, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 10, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 31:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 32:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 33:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 34:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 35:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 36:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 37:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 38:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 39:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 40:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFCSRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 41:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFCSRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 42:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeCFRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 43:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeCFRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 44:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeCFRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 45:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeCFRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 46:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 47:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 48:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 12);
    if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 49:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 12);
    if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 50:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 14);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 51:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 14);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 52:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRNoR0R1RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 14);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 53:
    tmp = fieldFromInstruction(insn, 0, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 12);
    if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 54:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 55:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 56:
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 57:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 15, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 58:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 15, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 59:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 15, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 60:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 15, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 61:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeCFRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 62:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeCFRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 63:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 64:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 65:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 15, 3);
    if (!Check(S, DecodeCFRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 66:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 16);
    if (!Check(S, decodeSImmOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 67:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 20);
    if (!Check(S, decodeSImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 68:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 20);
    if (!Check(S, decodeSImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 69:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 14);
    if (!Check(S, decodeSImmOperand<14, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 70:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 14);
    if (!Check(S, decodeSImmOperand<14, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 71:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 12);
    if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 72:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 12);
    if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 73:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 12);
    if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 74:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 12);
    if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 75:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 9);
    if (!Check(S, decodeSImmOperand<9, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 76:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 10);
    if (!Check(S, decodeSImmOperand<10, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 77:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 11);
    if (!Check(S, decodeSImmOperand<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 78:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    if (!Check(S, decodeSImmOperand<8, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 79:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    if (!Check(S, decodeSImmOperand<8, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 80:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    if (!Check(S, decodeSImmOperand<8, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 81:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 82:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 9);
    if (!Check(S, decodeSImmOperand<9, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 83:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 10);
    if (!Check(S, decodeSImmOperand<10, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 84:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 11);
    if (!Check(S, decodeSImmOperand<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 85:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    if (!Check(S, decodeSImmOperand<8, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 86:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    if (!Check(S, decodeSImmOperand<8, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 87:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    if (!Check(S, decodeSImmOperand<8, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 88:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 18, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 89:
    tmp = fieldFromInstruction(insn, 0, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 90:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 91:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeFPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 92:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 93:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 94:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 95:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 96:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 97:
    if (!Check(S, DecodeAMOrUDInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 98:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 5) << 16;
    tmp |= fieldFromInstruction(insn, 10, 16);
    if (!Check(S, decodeSImmOperand<21, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 99:
    tmp = fieldFromInstruction(insn, 5, 3);
    if (!Check(S, DecodeCFRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 5) << 16;
    tmp |= fieldFromInstruction(insn, 10, 16);
    if (!Check(S, decodeSImmOperand<21, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 100:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 5) << 16;
    tmp |= fieldFromInstruction(insn, 10, 16);
    if (!Check(S, decodeSImmOperand<21, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 101:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 16);
    if (!Check(S, decodeSImmOperand<16, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 102:
    tmp = 0x0;
    tmp |= fieldFromInstruction(insn, 0, 10) << 16;
    tmp |= fieldFromInstruction(insn, 10, 16);
    if (!Check(S, decodeSImmOperand<26, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 103:
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 16);
    if (!Check(S, decodeSImmOperand<16, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 104:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 105:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 106:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 107:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 108:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 109:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 110:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeCFRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 111:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 112:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 113:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 114:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 115:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 116:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 117:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 118:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 119:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 120:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 121:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 122:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 123:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 124:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 125:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 126:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 127:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 7);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 128:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 129:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 130:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLSX128RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 13);
    if (!Check(S, decodeSImmOperand<13>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 131:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 132:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 133:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 134:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 135:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 5);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 136:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 137:
    tmp = fieldFromInstruction(insn, 0, 3);
    if (!Check(S, DecodeCFRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 138:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    return S;
  case 139:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 140:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 141:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 142:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 143:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 144:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 145:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 146:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 147:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 1);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 148:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 3);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 149:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 2);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 150:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 4);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 151:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 6);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 152:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 7);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 153:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 154:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 10, 8);
    MI.addOperand(MCOperand::createImm(tmp));
    return S;
  case 155:
    tmp = fieldFromInstruction(insn, 0, 5);
    if (!Check(S, DecodeLASX256RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
    tmp = fieldFromInstruction(insn, 5, 13);
    if (!Check(S, decodeSImmOperand<13>(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[LoongArch::Feature64Bit];
  }
}


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

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

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

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

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

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


} // namespace
